标签: serde

假设我有一个&mut std::collections::HashMap, 我想将所有键都变成大写。下面的代码可以解决这个问题：

use std::collections::HashMap;

fn keys_to_upper<T>(map: &mut HashMap<String, T>) {
    let mut tmp = Vec::with_capacity(map.len());
    for (key, val) in map.drain() {
        tmp.push((key.to_ascii_uppercase(), val));
    }
    for (key, val) in tmp {
        map.insert(key, val);
    }
}

不幸的是，我没有 aHashMap而是 a &mut serde_json::Map，并且我想将所有键都变成大写。没有.drain()办法。我可以使用.into_iter()它，但这只会给我提供对键和值的可变引用。要将它们再次插入地图中，我必须克隆它们，这会损害性能。

这里有什么方法可以解决该.drain()方法的缺失吗？

我有一段serde代码可以实现我想要的功能，但我不喜欢它的实现方式。我正在寻求帮助以了解如何改进它。

操场

use std::any::Any;\n\ntrait Model: std::fmt::Debug + Any {\n    fn as_any(&self) -> &dyn Any;\n}\n\nimpl Model for Generator {\n    fn as_any(&self) -> &dyn Any {\n        self\n    }\n}\nimpl Model for Connector {\n    fn as_any(&self) -> &dyn Any {\n        self\n    }\n}\n\n#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\npub struct Generator {\n    id: String,\n    #[serde(rename = "sourceID")]\n    source_id: String,\n}\n\n#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\npub struct Connector {\n    id: String,\n    #[serde(rename = "sourceID")]\n    source_id: String,\n}\n\n#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\n#[serde(tag = "type")]\nenum AllModels {\n    Generator(Generator),\n    Connector(Connector),\n}\n\nfn main() {\n    let …

我有一个孩子和父母的结构，如下所示：

#[serde(rename_all = "camelCase")]
pub struct Child {
    some_field: u64,
}

#[serde(rename_all = "snake_case")]
pub struct Parent {
    child: Child,
}

我希望他们两个都是snake_case。

子结构是在导入的库中定义的，因此我无法更改它，而且我不想重复它。

是否可以无效/覆盖camelCase子结构顶部的宏？在父级之上添加snake_case似乎不起作用。

我有一个东京TcpStream。我想T通过这个流传递一些类型。这种类型的T实现Serialize和Deserialize. 我怎样才能获得 aSink<T>和 a Stream<T>？

我找到了板条箱tokio_util和tokio_serde，但我不知道如何使用它们来做我想做的事情。

在 serde_json 库中，是否可以解析 json 并将一个属性名称映射到 Rust 中的另一个属性名称struct？

例如，解析这个json：

{
    "json_name": 3
}

进入这个结构：

StructName { struct_name: 3 }

请注意，“json_name”和“struct_name”是不同的。

我有多个与仅在运行时已知的序列化/反序列化对象相对应的结构，例如：

#[derive(Serialize, Deserialize)]
struct Car{
    model: i32,
    year: i32
}

#[derive(Serialize, Deserialize)]
struct Person{
    name: String,
    age: i32
}

然后我有序列化和反序列化的函数：

fn deserialize(data: Vec<u8>){
    let msg = str::from_utf8(data);
    serde_json::from_str(msg);
}

fn serialize(&self, object: Car) -> String{
    let msg = serde_json::to_string(&object).unwrap();
    return msg;
}

如何使反序列化函数反序列化为 Car 和 Person（可能还有许多其他不同类型）并返回对象？如何使序列化函数执行相同的操作：序列化 Car、Person 和其他对象（在函数的属性中接受这些类型）？

我在 Rust 中使用serde_json，调用 api 并得到一个非常大的 json 作为回报。

我的问题是，是否可以部分反序列化此 JSON。我所说的部分是指 JSON 响应的某些属性，但不是所有属性。

例如，我有这个 JSON：

 Object {
        "age_group": String(""),
        "amazon_product_url": String("https://www.amazon.com/dp/0063221489?tag=NYTBSREV-20"),
        "article_chapter_link": String(""),
        "asterisk": Number(0),
        "author": String("Jared Kushner"),
        "book_image": String("https://storage.googleapis.com/du-prd/books/images/9780063221482.jpg"),
        "book_image_height": Number(500),
        "book_image_width": Number(331),
        "book_review_link": String(""),
        "book_uri": String("nyt://book/e5ec4777-5f2f-5622-9288-9b1d96e8fe1d"),
        "buy_links": Array [
            Object {
                "name": String("Amazon"),
                "url": String("https://www.amazon.com/dp/0063221489?tag=NYTBSREV-20"),
            },
            Object {
                "name": String("Apple Books"),
                "url": String("https://goto.applebooks.apple/9780063221482?at=10lIEQ"),
            },
            Object {
                "name": String("Barnes and Noble"),
                "url": String("https://www.anrdoezrs.net/click-7990613-11819508?url=https%3A%2F%2Fwww.barnesandnoble.com%2Fw%2F%3Fean%3D9780063221482"),
            }
}

那么在这种情况下，是不是可以只抓抓buy_links属性amazon_product_url，不管别人呢？

如果值为 ，我想跳过字段序列化false。

在 JSON 中，这将序列化为Foo或。{bar: true}{}

#[derive(Serialize)]
pub struct Foo {
    // This does not compile - bool::is_false does not exist
    #[serde(skip_serializing_if = "bool::is_false")]
    pub bar: bool,
}

我正在使用 Rust 和 Serde。假设我有一个结构体想要保留创建它的 JSON 数据的副本，也许这样它就可以在其他地方重新发送相同的 JSON，而无需重新序列化。（它并不像只保留原始 JSON 数据的副本那么简单，因为该结构可能位于更多 JSON 数据中。）示例：

#[derive(Deserialize)]
struct LargerStruct {
    value: i32,
    inner: InnerStruct,
}

#[derive(Deserialize)]
struct InnerStruct {
    this_json: String,
    inner_value: i32,
}

fn main() {
    let json = r#"
        {
          "value": 42, 
          "inner": { "inner_value": 100 }
        }
    "#;

    let val: LargerStruct = // ???

    assert_eq!(&val.inner.this_json, r#"{ "inner_value": 100 }"#);
}

评论里可以填什么内容???？

我无法让以下代码工作（游乐场：https://play.rust-lang.org/? version=stable&mode= debug&edition=2021&gist=4379c2006dcf3d32f59b0e44626ca667）。

use serde::{Serialize, Deserialize};

trait InnerStruct<'delife>: Deserialize<'delife> + Serialize {}

#[derive(Serialize, Deserialize)]
struct InnerStructA{
    a: i32
}

impl InnerStruct<'_> for InnerStructA {}

#[derive(Serialize, Deserialize)]
struct InnerStructB{
    a: i32,
    b: i32
}

impl InnerStruct<'_> for InnerStructB {}

#[derive(Serialize, Deserialize)]
struct OuterStruct<T: InnerStruct>{   // Remove the word "InnerStruct" and this works
    c: f64,
   inner: T
}

fn print_json<T: for<'a> InnerStruct<'a>>(obj: T) {
    println!("Serde JSON: {:?}", serde_json::to_string(&obj).unwrap());
}

fn main() {
    let inner_a = InnerStructA{a: 123};
    let inner_b = InnerStructB{a: …