Início / coding / Perguntas / 79422367
Accepted
Popeye
Asked: 2025-02-08 07:25:18 +0800 CST

Perplexo com o mapa serde_json

  • 772

Estou tentando gerar um objeto json como abaixo

// final json output expected
{
    "j1": {
        "1981": {
            "income": 215
        },
        "1982": {
            "income": 350
        },
    },
    "j2": {
        "1981": {
            "income": 100
        },
        "1982": {
            "income": 215
        },
    }
}

Eu tenho o seguinte código

use serde_json::{Value, Map};

struct s {
    name: String,
    year: i32,
    income: i64
}

fn main() {
    let rows :Vec<s> = vec!(
        s { name: "j1".to_string(), year: 1981, income: 100},
        s { name: "j1".to_string(), year: 1981, income: 115},
        s { name: "j1".to_string(), year: 1982, income: 120},
        s { name: "j1".to_string(), year: 1982, income: 100},
        s { name: "j1".to_string(), year: 1982, income: 130},
        s { name: "j2".to_string(), year: 1981, income: 100},
        s { name: "j2".to_string(), year: 1982, income: 120},
        s { name: "j2".to_string(), year: 1982, income: 130}
    );
    
    let mut data_map: Map<String, Value> = Map::new();
    for row in rows {
        let  mut name: &Map<String, Value> = match data_map.get(&row.name) {
            Some(val) => { &val.as_object().unwrap() },
            None => { &Map::new() }
        };
        let mut year:  &Map<String, Value> = match data_map.get(&row.year.to_string()) {
            Some(val) => { &val.as_object().unwrap() },
            None => { &Map::new() }
        };
        let income: i64 = year.get("income").unwrap_or(&Value::Number(0i64.into())).as_i64().unwrap() + row.income;
        year.insert("income".to_string(), Value::Number(income.into()));
    }
}

Criei este código para fazer a pergunta. Também consultei o deepseek e tal

A mensagem de erro que estou recebendo é

error[E0596]: cannot borrow `*year` as mutable, as it is behind a `&` reference
  --> src\main.rs:32:9
   |
32 |         year.insert("income".to_string(), Value::Number(income.into()));
   |         ^^^^ `year` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
help: consider changing this binding's type
   |
27 |         let mut year: &mut serde_json::Map<std::string::String, Value> = match data_map.get(&row.year.to_string()) {
   |                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Claramente tenho deficiência em entender referência e empréstimo. Qualquer ajuda seria apreciada.

rust

2 respostas

  1. Best Answer

    Primeiro, você não costuma criar JSON manualmente. Você cria uma representação Rust dele e então deixa serde_jsonconvertê-lo para JSON. Isso significa, não lide com Valuevocê mesmo.

    Claro que você também pode construir JSONs manualmente, mas isso raramente tem alguma vantagem sobre deixar serde_jsonfazer isso.

    Aqui está uma solução. Primeiro, precisamos das seguintes dependências em Cargo.toml:

    [dependencies]
serde = { version = "1.0.217", features = ["derive"] }
serde_json = "1.0.138"

    E aqui está o código:

    use serde::{Deserialize, Serialize};

use std::collections::HashMap;

struct S {
    name: String,
    year: i32,
    income: i64,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
struct YearData {
    income: i64,
}

fn main() {
    let rows: Vec<S> = vec![
        S { name: "j1".to_string(), year: 1981, income: 100 },
        S { name: "j1".to_string(), year: 1981, income: 115 },
        S { name: "j1".to_string(), year: 1982, income: 120 },
        S { name: "j1".to_string(), year: 1982, income: 100 },
        S { name: "j1".to_string(), year: 1982, income: 130 },
        S { name: "j2".to_string(), year: 1981, income: 100 },
        S { name: "j2".to_string(), year: 1982, income: 120 },
        S { name: "j2".to_string(), year: 1982, income: 130 },
    ];

    let mut data_map: HashMap<String, HashMap<String, YearData>> = HashMap::new();
    for row in rows {
        data_map
            .entry(row.name)
            .or_default()
            .entry(row.year.to_string())
            .or_insert(YearData { income: 0 })
            .income += row.income;
    }

    let serde_string = serde_json::to_string_pretty(&data_map).unwrap();

    println!("{}", serde_string);
}

    {
  "j1": {
    "1982": {
      "income": 350
    },
    "1981": {
      "income": 215
    }
  },
  "j2": {
    "1981": {
      "income": 100
    },
    "1982": {
      "income": 250
    }
  }
}

    Sobre o erro de empréstimo no seu código original: não tenho certeza de como ajudar você nisso. Há muitos erros aí, tanto problemas de propriedade quanto problemas lógicos.

    Presumo que você pretende consultar um membro de data_mapusando a row.namechave e, se ela não existir, insira um novo mapa. Vejo que você cria um novo mapa, mas nunca o insere em data_maplugar nenhum. O resto dos problemas são um monte de &coisas que estão erradas, às vezes porque os valores já são referências e, às vezes, porque são para variáveis ​​que são temporárias e você cria referências pendentes.

    Eu adoraria dissecar seu código com mais detalhes e explicar os erros para você, mas é meio confuso fazer isso :D

    Em vez disso, aqui vai uma reescrita. Talvez ajude seu entendimento:

    use serde_json::{Map, Value};

struct S {
    name: String,
    year: i32,
    income: i64,
}

fn main() {
    let rows: Vec<S> = vec![
        S { name: "j1".to_string(), year: 1981, income: 100 },
        S { name: "j1".to_string(), year: 1981, income: 115 },
        S { name: "j1".to_string(), year: 1982, income: 120 },
        S { name: "j1".to_string(), year: 1982, income: 100 },
        S { name: "j1".to_string(), year: 1982, income: 130 },
        S { name: "j2".to_string(), year: 1981, income: 100 },
        S { name: "j2".to_string(), year: 1982, income: 120 },
        S { name: "j2".to_string(), year: 1982, income: 130 },
    ];

    let mut data_map: Map<String, Value> = Map::new();
    for row in rows {
        let name: &mut Map<String, Value> = data_map
            .entry(row.name)
            .or_insert_with(|| Map::new().into())
            .as_object_mut()
            .unwrap();
        let year: &mut Map<String, Value> = name
            .entry(row.year.to_string())
            .or_insert_with(|| Map::new().into())
            .as_object_mut()
            .unwrap();
        let income: i64 = year
            .get("income")
            .unwrap_or(&Value::Number(0i64.into()))
            .as_i64()
            .unwrap()
            + row.income;
        year.insert("income".to_string(), Value::Number(income.into()));
    }

    println!("{}", serde_json::to_string_pretty(&data_map).unwrap());
}

    {
  "j1": {
    "1981": {
      "income": 215
    },
    "1982": {
      "income": 350
    }
  },
  "j2": {
    "1981": {
      "income": 100
    },
    "1982": {
      "income": 250
    }
  }
}

    Mas, novamente, não faça isso a menos que seja absolutamente necessário; serde_jsonnão é realmente feito para ser usado dessa forma. Usar Valuediretamente só causa muitos as_<type>().unwrap()casts, e não há nenhuma vantagem real sobre usar um tipo Rust que implementa serde::Serialize. É assim serde_jsonque deve ser usado; veja #[derive(Serialize)]no meu primeiro exemplo. Recomendo ler serde.rs para mais informações.

    • 1

  2. o que você está tentando alcançar não está claro:

    No seu primeiro trecho de código (a saída JSON esperada), parece que você quer um objeto JSON com uma lista de objetos aninhados onde cada um tem um nome, por exemplo, j1correspondendo a uma lista de objetos com uma renda por ano.

    No entanto, esta não é uma maneira muito padrão de escrever JSON. Normalmente, você tem nomes de variáveis ​​e valores separados por uma coluna :, e vários elementos do mesmo tipo são armazenados em um array, que é o que você faz no seu segundo trecho de código.

    Não entendo por que você está tentando usar um serde_json::Map aqui. Se você quiser apenas imprimir como uma string json seu rowsobjeto, você pode modificar seu código para o seguinte (certifique-se de adicionar o crate serde com o recurso derive executando cargo add serde --features=derive)

    use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, PartialEq, Serialize)]
struct S {
    name: String,
    year: i32,
    income: i64,
}

fn main() {
    let rows: Vec<S> = vec![
        S { name: "j1".to_string(), year: 1981, income: 100},
        S { name: "j1".to_string(), year: 1981, income: 115},
        S { name: "j1".to_string(), year: 1982, income: 120},
        S { name: "j1".to_string(), year: 1982, income: 100},
        S { name: "j1".to_string(), year: 1982, income: 130},
        S { name: "j2".to_string(), year: 1981, income: 100},
        S { name: "j2".to_string(), year: 1982, income: 120},
        S { name: "j2".to_string(), year: 1982, income: 130}
    ];

    let json_rows = serde_json::to_string(&rows).unwrap();
    println!("{json_rows}",);
}

    Você deverá ver o seguinte (após a formatação para multilinha):

    [
    {
        "name": "j1",
        "year": 1981,
        "income": 100
    },
    {
        "name": "j1",
        "year": 1981,
        "income": 115
    },
    {
        "name": "j1",
        "year": 1982,
        "income": 120
    },
    {
        "name": "j1",
        "year": 1982,
        "income": 100
    },
    {
        "name": "j1",
        "year": 1982,
        "income": 130
    },
    {
        "name": "j2",
        "year": 1981,
        "income": 100
    },
    {
        "name": "j2",
        "year": 1982,
        "income": 120
    },
    {
        "name": "j2",
        "year": 1982,
        "income": 130
    }
]

    Espero que isso ajude

    • -1

relate perguntas