在Rust中使用Serde序列化/反序列化&[f64]的问题与解决

问题重现 #

可正常编译的代码 #

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    value: f64
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let perspn = Person { name: "me".into(), value: 30_f64};
    let serialized = serde_json::to_string(&perspn).unwrap();
    println!("{:?}", serialized);
    Ok(())
}

修改后编译失败的代码 #

将结构体成员改为&[f64]后，编译报错：

#[derive(Serialize, Deserialize)]
struct Person<'a> {
    name: String,
    value: &'a[f64]
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let perspn = Person { name: "me".into(), value: &[30_f64]};
    let serialized = serde_json::to_string(&perspn).unwrap();
    println!("{:?}", serialized);
    Ok(())
}

报错信息 #

error[E0277]: the trait bound `&[f64]: Deserialize<'_>` is not satisfied
   --> src/main.rs:168:5
    |
168 |     value: &'a[f64]
    |     ^^^^^ the trait `Deserialize<'_>` is not implemented for `&[f64]`
    |
    = help: the following other types implement trait `Deserialize<'de>`:
              &'a [u8]
              [T; 0]
              [T; 10]
              [T; 11]
              [T; 12]
              [T; 13]
              [T; 14]
              [T; 15]
            and 26 others

问题原因解析 #

1. 引用类型反序列化的本质限制 #

反序列化的核心是从序列化数据中创建新的数据实例，而&[T]是借用类型，本身不持有数据，只能指向已存在的内存区域。对于f64这类非字节类型，JSON数组元素需要解码为独立的f64值，这些值必须存储在拥有所有权的容器（比如Vec<f64>）中，&[f64]无法直接引用刚分配的内存——除非数据是静态的，但通用场景下无法保证这一点，因此Serde默认不为非u8的切片实现Deserialize trait。

2. 为何默认支持&[u8]？ #

&[u8]是特殊情况：JSON字符串可直接解码为字节切片，且在处理base64编码的二进制数据等场景中，&[u8]能直接借用输入序列化数据的内存，无需额外分配新内存存储元素。Serde专门为&[u8]实现了反序列化逻辑，利用了JSON字符串的二进制特性，因此它成为少数默认支持反序列化的引用类型切片。

解决方法 #

方法1：调整结构体设计（推荐） #

将&[f64]替换为Vec<f64>，需要借用切片时直接通过&*value获取：

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    value: Vec<f64>
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let person = Person { name: "me".into(), value: vec![30_f64]};
    let serialized = serde_json::to_string(&person).unwrap();
    println!("{:?}", serialized);
    
    // 反序列化后获取切片引用
    let deserialized: Person = serde_json::from_str(&serialized).unwrap();
    let value_slice: &[f64] = &deserialized.value;
    Ok(())
}

方法2：自定义反序列化器（不推荐，仅作演示） #

如果必须让结构体持有&[f64]，需要先将数据反序列化为拥有所有权的容器（如Vec<f64>），再确保数据的生命周期足够长。但这种方式非常受限，容易引发悬垂引用问题，仅作技术演示：

use serde::{Deserialize, Deserializer};

// 定义中间结构体用于反序列化
#[derive(Deserialize)]
struct PersonIntermediate {
    name: String,
    value: Vec<f64>
}

#[derive(Serialize)]
struct Person<'a> {
    name: String,
    value: &'a [f64]
}

impl<'de: 'a, 'a> Deserialize<'de> for Person<'a> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let intermediate = PersonIntermediate::deserialize(deserializer)?;
        // 注意：此处必须保证intermediate的生命周期足够长，否则会报错
        // 实际场景中需要将intermediate存储在结构体或外部持久化容器中
        Ok(Person {
            name: intermediate.name,
            value: &intermediate.value,
        })
    }
}

自定义反序列化器的边缘注意事项 #

• 生命周期安全：涉及引用类型时，必须确保被引用数据的生命周期至少与结构体一致，避免悬垂引用。
• 空数组处理：要兼容JSON中的空数组场景，不能直接panic，需正确返回空切片或空容器。
• 类型不匹配处理：当JSON中的元素类型与目标类型不匹配时（比如数组里出现字符串），要返回清晰的错误信息，而非崩溃。
• 性能优化：处理大数组时，尽量避免不必要的内存分配，优先复用已有内存。
• 多格式兼容性：自定义逻辑要符合Serde通用规范，确保能兼容JSON以外的Serde格式（如Bincode、MessagePack）。

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