Processamento de JSON em Rust: bibliotecas serde_json e json

Processamento de JSON em Rust: serde_json e trabalho com dados

JSON (JavaScript Object Notation) continua sendo um dos formatos de troca de dados mais populares no desenvolvimento web, APIs e arquivos de configuração. Na linguagem Rust, conhecida por seu desempenho e segurança, o trabalho com JSON é implementado através de um poderoso ecossistema de crates. A principal ferramenta é a biblioteca serde_json, construída sobre o framework de serialização serde. Neste artigo, vamos detalhar como analisar, criar e transformar JSON em Rust, além de abordar abordagens alternativas.

1. Instalação e configuração do serde_json

Para começar, adicione as dependências no arquivo Cargo.toml:

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

serde fornece os traits Serialize e Deserialize, enquanto serde_json fornece a implementação específica para JSON. Após adicionar os crates, você pode importá-los no código:

use serde::{Deserialize, Serialize};use serde_json::Result;

2. Serialização de estruturas para JSON

Para converter uma estrutura Rust em JSON, é necessário anotá-la com os atributos #[derive(Serialize)]. Veja um exemplo com dados de usuário:

#[derive(Serialize)]struct User {    name: String,    age: u8,    email: String,    active: bool,}

fn main() -> Result<()> {    let user = User {        name: "Alexey".to_string(),        age: 30,        email: "alex@example.com".to_string(),        active: true,    };

    let json = serde_json::to_string(&user)?;    println!("{}", json);    // Saída: {"name":"Alexey","age":30,"email":"alex@example.com","active":true}    Ok(())}

O método serde_json::to_string retorna um Result<String>. Para saída formatada, use serde_json::to_string_pretty.

3. Desserialização de JSON para estruturas

O processo inverso — converter uma string JSON em uma estrutura Rust. Para isso, a estrutura deve implementar Deserialize:

#[derive(Deserialize, Debug)]struct User {    name: String,    age: u8,    email: String,    active: bool,}

fn main() -> Result<()> {    let data = r#"        {            "name": "Maria",            "age": 25,            "email": "maria@example.com",            "active": false        }"#;

    let user: User = serde_json::from_str(data)?;    println!("{:?}", user);    // Saída: User { name: "Maria", age: 25, email: "maria@example.com", active: false }    Ok(())}

Se o JSON contiver campos ausentes na estrutura, ou vice-versa, use os atributos #[serde(default)] ou #[serde(skip_serializing_if = "Option::is_none")].

4. Trabalhando com JSON arbitrário (Value)

Às vezes, a estrutura dos dados não é conhecida antecipadamente. Nesses casos, usa-se a enumeração serde_json::Value, que pode representar qualquer tipo JSON:

use serde_json::Value;

fn main() -> Result<()> {    let data = r#"        {            "name": "Ivan",            "age": 35,            "hobbies": ["leitura", "programação"],            "address": null        }"#;

    let v: Value = serde_json::from_str(data)?;

    // Acesso aos campos    if let Some(name) = v.get("name") {        println!("Nome: {}", name);    }

    // Extração de array    if let Some(hobbies) = v.get("hobbies").and_then(|h| h.as_array()) {        for hobby in hobbies {            println!("Hobby: {}", hobby);        }    }

    Ok(())}

Value suporta métodos como as_str(), as_u64(), as_array() e outros para extração segura de dados.