Processamento JSON em Rust: biblioteca serde_json para site educacional

Processamento JSON em Rust: guia completo com serde_json

JSON (JavaScript Object Notation) é um dos formatos de troca de dados mais populares no desenvolvimento web. Em Rust, o processamento JSON é feito usando a poderosa biblioteca serde_json, que faz parte do ecossistema Serde — um framework para serialização e desserialização de estruturas de dados. Neste artigo, vamos detalhar como trabalhar com JSON em Rust: desde a instalação até exemplos complexos com estruturas aninhadas.

Instalação e configuração

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

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

A biblioteca serde fornece as macros #[derive(Serialize, Deserialize)], e serde_json é responsável pela conversão de dados para JSON e vice-versa.

Serialização e desserialização básicas

Vamos ver um exemplo simples: criar uma estrutura User e aprender a convertê-la para JSON e vice-versa.

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

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

fn main() {    // Criando uma instância da estrutura    let user = User {        name: "Алексей".to_string(),        age: 30,        email: "alex@example.com".to_string(),    };

    // Serialização para string JSON    let json_string = serde_json::to_string(&user).unwrap();    println!("JSON: {}", json_string);

    // Desserialização de JSON de volta para a estrutura    let deserialized_user: User = serde_json::from_str(&json_string).unwrap();    println!("Desserializado: {:?}", deserialized_user);}

Resultado da execução:

JSON: {"name":"Алексей","age":30,"email":"alex@example.com"}Desserializado: User { name: "Алексей", age: 30, email: "alex@example.com" }

Trabalhando com estruturas aninhadas

JSON frequentemente contém objetos e arrays aninhados. Rust permite modelar essas estruturas facilmente:

#[derive(Debug, Serialize, Deserialize)]struct Address {    city: String,    street: String,    house: u16,}

#[derive(Debug, Serialize, Deserialize)]struct Person {    name: String,    age: u8,    address: Address,    hobbies: Vec<String>,}

fn main() {    let person = Person {        name: "Мария".to_string(),        age: 25,        address: Address {            city: "Москва".to_string(),            street: "Тверская".to_string(),            house: 10,        },        hobbies: vec!["чтение".to_string(), "спорт".to_string()],    };

    // Saída JSON formatada com indentação    let pretty_json = serde_json::to_string_pretty(&person).unwrap();    println!("{}", pretty_json);}

Saída:

{  "name": "Мария",  "age": 25,  "address": {    "city": "Москва",    "street": "Тверская",    "house": 10  },  "hobbies": [    "чтение",    "спорт"  ]}

Tratamento de erros e campos opcionais

Em projetos reais, os dados podem estar incompletos. Rust oferece maneiras elegantes de lidar com essas situações:

• Option<T> — para campos opcionais
• Result<T, E> — para tratamento de erros de parsing
• Atributos Serde — para configurar o comportamento da serialização

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

#[derive(Debug, Serialize, Deserialize)]struct Product {    name: String,    price: f64,    #[serde(default)] // Valor padrão se o campo estiver ausente    description: Option<String>,    #[serde(skip_serializing_if = "Option::is_none")] // Pular se for None    discount: