在rust中序列化反序列化JSON我们常用的是serde这个包，但是json中有一种情况就是存在不确定类型的字段，或者说这个字段可能是多种类型；在golang中，我们用interface{}类型来表达，在java中，我们用Object表达，那么在rust应该如何表达呢。直接说结果，用enum来组合类型

比如我定义了一种JSON数据结构，如下

// 第一种
{
    "msg_type": "resize",
    "content": {
        "width": 12,
        "height": 3
    }
}

// 第二种
{
    "msg_type": "ping",
    "content": {
        "ts": 123
    }
}

很明显，两个数据中，content字段表现的类型不一样，在msg_type为resize时content字段是一种结构体，msg_type为ping时content字段是另一种结构体。我们定义枚举和结构体如下

#[derive(Clone, Debug, Deserialize)]
struct ControlMessage {
    msg_type: String,
    #[serde(default)]
    content: ControlContent,
}

#[derive(Clone, Debug, Deserialize, PartialEq)]
#[serde(untagged)]
enum ControlContent {
    Empty,
    Resize(ResizeControl),
    Time(TimeControl),
}

impl Default for ControlContent {
    fn default() -> Self {
        Self::Empty
    }
}

#[derive(Clone, Debug, Deserialize, PartialEq)]
struct ResizeControl {
    width: u32,
    height: u32,
}

#[derive(Clone, Debug, Deserialize, PartialEq)]
struct TimeControl {
    ts: u32,
}

可以看到我们定义了两种类型ResizeControl和TimeControl，需要注意以下几点：

1. 要支持反序列化，所有用到的结构体都需要添加Deserialize注解
2. 枚举中，Empty,Resize,Time这3个都属于枚举的字段名，圆括号()里定义类型，没有定义的表示空
3. 枚举上，需要添加untagged注解
4. 要为枚举实现Default::default方法，否则无法被Deserialize注解
5. 被枚举引用的结构体ResizeControl,TimeControl，以及枚举ControlContent都需要加上PartialEq注解，否则无法在枚举圆括号()中引用

调用反序列化

#[test]
pub fn test_field_deserialize() -> serde_json::Result<()> {
    let a = r#"{"msg_type": "resize", "content": {"width": 12, "height": 3}}"#;
    let v: ControlMessage = serde_json::from_str(a)?;
    println!("v: {:?}", v);

    let b = r#"{"msg_type": "resize", "content": {"ts": 123}}"#;
    let v: ControlMessage = serde_json::from_str(b)?;
    println!("v: {:?}", v);

    Ok(())
}

结果调用成功

running 1 test
v: ControlMessage { msg_type: "resize", content: Resize(ResizeControl { width: 12, height: 3 }) }
v: ControlMessage { msg_type: "resize", content: Time(TimeControl { ts: 123 }) }
test control::test_field_deserialize ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

在rust中，我们在一开始学习rust时，就被告诉，在函数结尾可以不用写return，只需要结尾的那个语句别写分号(;)，那么结尾的这个语句计算的值将会作为这个函数的返回值返回。

#[test]
fn test_return_2() {
    println!("none semi: {}", none_semicolon());
}

fn none_semicolon() -> String {
    String::from("hello world")
}

正常输出

running 1 test
none semi: hello world
test test_return_2 ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

这时，我形成一个印象，“结尾语句不加分号，可以当return用”。还有如下的例子

fn test_return_1() -> bool {
    let x = Option::Some(true);

    let y = match x {
        Some(val) => {
            println!("{:?}", val);
            val
        }
        None => false,
    };

    println!("will finish function, y: {:?}", y);

    false
}

我可以看到y变量是bool类型，这时候我以为val这句没有加分号，所以它将值返回给语句块，从而赋值给y，但是，这时候，我改为下面这样的

#[test]
fn test_return_2() {
    println!("none semi: {}", test_return_1());
}

fn test_return_1() -> bool {
    let x = Option::Some(true);

    let y = match x {
        Some(val) => {
            println!("{:?}", val);
            return val;
        }
        None => false,
    };

    println!("will finish function, y: {:?}", y);

    false
}

我发现，return 处就结束了函数并返回。后续的println并没有执行。

running 1 test
true
none semi: true
test test_return_2 ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

总结，位于语句块或者函数体结尾无分号结尾的语句，并不等同于return，它处于语句块结尾时，代表将它的值赋值给语句块所代表的变量，处于函数体结尾时，代表将它的值赋值给函数体所代表的变量（函数返回变量）；而return这个函数终止返回的指令，从来都跟无分号结尾的语句无关，而是函数体的反花括号 (}) 的出现所带来的行为。