比较枚举变体及其值时如何避免代码重复？（Serde JSON场景）

我太懂这种重复代码的痛苦了——对着枚举每个变体写几乎一模一样的匹配逻辑，不仅啰嗦，后期维护也容易出错。在Rust里，我们有几种优雅的方式来解决这个问题，不一定非要依赖宏（当然宏也是个好用的选项），下面给你详细拆解：

方法一：先统一检查类型，再针对性比较 #

核心思路是：先判断两个Value的变体类型是否一致，不一致直接返回Diff::NotFound；一致的话再比较内部值。这样每个变体的匹配逻辑就不用重复判断对方的类型了。

首先我们可以写一个辅助函数来获取Value的类型标识：

#[derive(PartialEq, Eq)]
enum ValueType {
    Null,
    Bool,
    Number,
    String,
    Array,
    Object,
}

fn value_type(val: &Value) -> ValueType {
    match val {
        Value::Null => ValueType::Null,
        Value::Bool(_) => ValueType::Bool,
        Value::Number(_) => ValueType::Number,
        Value::String(_) => ValueType::String,
        Value::Array(_) => ValueType::Array,
        Value::Object(_) => ValueType::Object,
    }
}

然后改造你的compare函数：

fn compare(val1: &Value, val2: &Value) -> Diff {
    // 先检查类型是否一致，不一致直接返回NotFound
    if value_type(val1) != value_type(val2) {
        return Diff::NotFound;
    }

    // 类型一致，直接匹配对应变体比较值
    match (val1, val2) {
        (Value::Null, Value::Null) => Diff::Equal,
        (Value::Bool(b1), Value::Bool(b2)) => {
            if b1 == b2 { Diff::Equal } else { Diff::Different }
        }
        (Value::Number(n1), Value::Number(n2)) => {
            if n1 == n2 { Diff::Equal } else { Diff::Different }
        }
        (Value::String(s1), Value::String(s2)) => {
            if s1 == s2 { Diff::Equal } else { Diff::Different }
        }
        (Value::Array(a1), Value::Array(a2)) => {
            // 数组递归比较：先看长度，再逐个元素比较
            if a1.len() != a2.len() {
                return Diff::Different;
            }
            for (item1, item2) in a1.iter().zip(a2.iter()) {
                match compare(item1, item2) {
                    Diff::Equal => continue,
                    diff => return diff,
                }
            }
            Diff::Equal
        }
        (Value::Object(o1), Value::Object(o2)) => {
            // 对象递归比较：先看键的数量，再逐个键值对比较
            if o1.len() != o2.len() {
                return Diff::Different;
            }
            for (key, val1_item) in o1 {
                match o2.get(key) {
                    Some(val2_item) => match compare(val1_item, val2_item) {
                        Diff::Equal => continue,
                        diff => return diff,
                    },
                    None => return Diff::NotFound,
                }
            }
            Diff::Equal
        }
        // 前面已经检查过类型一致，这里不会触发
        _ => unreachable!("Value types were pre-checked to match"),
    }
}

这种方式把重复的类型判断逻辑抽离到了开头，后续的匹配只需要处理同类型的情况，代码简洁了很多。

方法二：用宏自动生成重复的匹配逻辑 #

如果你觉得手动写每个变体的比较还是麻烦，可以用Rust的宏来自动生成这些代码，类似C++里宏的作用，但更安全。

我们可以写一个宏，接收变体名称和内部类型，自动生成对应的比较分支：

macro_rules! generate_compare_variants {
    ($($variant:ident($ty:ty)),*) => {
        fn compare(val1: &Value, val2: &Value) -> Diff {
            match (val1, val2) {
                // 宏生成的基础变体比较逻辑
                $(
                    (Value::$variant(v1), Value::$variant(v2)) => {
                        if v1 == v2 { Diff::Equal } else { Diff::Different }
                    }
                )*
                // 单独处理Null
                (Value::Null, Value::Null) => Diff::Equal,
                // 递归处理数组
                (Value::Array(a1), Value::Array(a2)) => {
                    if a1.len() != a2.len() {
                        return Diff::Different;
                    }
                    for (item1, item2) in a1.iter().zip(a2.iter()) {
                        match compare(item1, item2) {
                            Diff::Equal => continue,
                            diff => return diff,
                        }
                    }
                    Diff::Equal
                }
                // 递归处理对象
                (Value::Object(o1), Value::Object(o2)) => {
                    if o1.len() != o2.len() {
                        return Diff::Different;
                    }
                    for (key, val1_item) in o1 {
                        match o2.get(key) {
                            Some(val2_item) => match compare(val1_item, val2_item) {
                                Diff::Equal => continue,
                                diff => return diff,
                            },
                            None => return Diff::NotFound,
                        }
                    }
                    Diff::Equal
                }
                // 类型不匹配的情况
                _ => Diff::NotFound,
            }
        }
    };
}

// 调用宏，传入需要自动生成逻辑的变体
generate_compare_variants!(Bool(bool), Number(Number), String(String));

这个宏会帮你自动生成Bool、Number、String这几个变体的比较分支，你只需要维护宏调用里的变体列表即可，非常适合变体较多的场景。

方法三：利用serde_json::Value自带的PartialEq实现 #

其实serde_json::Value已经默认实现了PartialEq trait，我们可以直接利用这个特性来简化代码：

fn compare(val1: &Value, val2: &Value) -> Diff {
    match (val1, val2) {
        (Value::Null, Value::Null) => Diff::Equal,
        // 把同类型的基础变体合并成一个分支，直接用PartialEq比较
        (Value::Bool(_), Value::Bool(_)) |
        (Value::Number(_), Value::Number(_)) |
        (Value::String(_), Value::String(_)) => {
            if val1 == val2 { Diff::Equal } else { Diff::Different }
        }
        // 数组和对象的递归逻辑和之前一致
        (Value::Array(a1), Value::Array(a2)) => {
            if a1.len() != a2.len() {
                return Diff::Different;
            }
            for (item1, item2) in a1.iter().zip(a2.iter()) {
                match compare(item1, item2) {
                    Diff::Equal => continue,
                    diff => return diff,
                }
            }
            Diff::Equal
        }
        (Value::Object(o1), Value::Object(o2)) => {
            if o1.len() != o2.len() {
                return Diff::Different;
            }
            for (key, val1_item) in o1 {
                match o2.get(key) {
                    Some(val2_item) => match compare(val1_item, val2_item) {
                        Diff::Equal => continue,
                        diff => return diff,
                    },
                    None => return Diff::NotFound,
                }
            }
            Diff::Equal
        }
        _ => Diff::NotFound,
    }
}

这种方式把三个基础变体的比较逻辑合并成了一个分支，直接复用了标准库的PartialEq实现，代码最简洁。

内容的提问来源于stack exchange，提问作者Nick