Início / coding / Perguntas / 79309760
Accepted
user2138149
Asked: 2024-12-26 23:03:21 +0800 CST

Como desserializar uma entrada JSON como uma estrutura de dados genérica em Rust?

  • 772

A maioria dos exemplos que mostram a desserialização de JSON com Rust serde_jsonmostram a desserialização em um formato de estrutura conhecido, usando um struct.

É possível desserializar um documento JSON com uma estrutura desconhecida em um tipo de dado Rust genérico que pode lidar com essa variação estrutural?

Por exemplo, eu tentei algo assim

let filename = "example.json";
let maybe_ifile = std::fs::File::open(filename);

match maybe_ifile {
    Ok(ifile) => {
        let maybe_json_data = serde_json::from_reader::<_, BTreeMap<String, String>>(ifile);

        match maybe_json_data {
            Ok(json_data) => {
                println!("{json_data:?}");
            }

            Err(error) => {
                panic!("{error}")
            }
        }
    }

    Err(error) => {
        panic!("{error}");
    }
}

Isso funciona se o documento JSON for estruturado como pares de strings de chave-valor, mas não funciona para estruturas mais gerais, então claramente usar BTreeMap<String, String>não é a abordagem correta aqui.

O que estou tentando alcançar é flexibilidade usando tipos de tempo de execução/um tanto dinâmicos.

Isso é possível em outras linguagens, então presumo que haja uma solução bastante trivial em Rust, só não sei qual é.

json

1 respostas

  1. Best Answer

    A solução foi usar o serde_json::Valuedatatype. Isso fornece uma maneira genérica de trabalhar com dados JSON.

    A linha única mudou:

    let maybe_json_data = serde_json::from_reader::<_, serde_json::Value>(ifile);

    Exemplo de desserialização de documento JSON genérico

    Aqui está um exemplo de desserialização de uma string JSON em serde_json::Value:

    use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example JSON string
    let json_str = r#"
    {
        "name": "Alice",
        "age": 30,
        "is_member": true,
        "favorites": {
            "colors": ["red", "green", "blue"],
            "numbers": [1, 2, 3]
        }
    }
    "#;

    // Parse the JSON string into a serde_json::Value
    let json_value: Value = serde_json::from_str(json_str)?;

    // Accessing elements in the JSON
    if let Some(name) = json_value.get("name").and_then(|v| v.as_str()) {
        println!("Name: {}", name);
    }

    if let Some(age) = json_value.get("age").and_then(|v| v.as_i64()) {
        println!("Age: {}", age);
    }

    if let Some(is_member) = json_value.get("is_member").and_then(|v| v.as_bool()) {
        println!("Is Member: {}", is_member);
    }

    // Nested JSON objects
    if let Some(favorites) = json_value.get("favorites") {
        if let Some(colors) = favorites.get("colors").and_then(|v| v.as_array()) {
            println!("Favorite Colors: {:?}", colors);
        }
    }

    Ok(())
}

    Explicação

    Analisando JSON: A função serde_json::from_str analisa a string JSON em um serde_json::Value.

    Acessando Dados: Use o getmétodo para acessar campos no JSON. Você pode usar métodos específicos de tipo como as_str, as_i64, e as_boolpara converter os valores JSON para tipos Rust.

    Manipulando JSON aninhado e complexo

    A serde_json::Valueenumeração pode representar dados JSON de qualquer estrutura:

    • Value::Objectpara objetos JSON
    • Value::Arraypara matrizes
    • Value::Stringpara cordas
    • Value::Numberpara números
    • Value::Boolpara booleanos
    • Value::Nullpara nulos

    Isso o torna adequado para desserialização JSON genérica quando a estrutura não é fixa.

    • 0

relate perguntas