Procesamiento de JSON en Rust: biblioteca serde_json para sitio educativo

Procesamiento de JSON en Rust: guía completa con serde_json

JSON (JavaScript Object Notation) es uno de los formatos de intercambio de datos más populares en el desarrollo web. En Rust, el procesamiento de JSON se realiza con la potente biblioteca serde_json, que forma parte del ecosistema Serde, un framework para la serialización y deserialización de estructuras de datos. En este artículo, analizaremos en detalle cómo trabajar con JSON en Rust: desde la instalación hasta ejemplos complejos con estructuras anidadas.

Instalación y configuración

Para comenzar, agregue las dependencias al archivo Cargo.toml:

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

La biblioteca serde proporciona las macros #[derive(Serialize, Deserialize)], y serde_json se encarga de la conversión de datos a JSON y viceversa.

Serialización y deserialización básicas

Veamos un ejemplo simple: crearemos una estructura User y aprenderemos a convertirla a JSON y viceversa.

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

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

fn main() {    // Creamos una instancia de la estructura    let user = User {        name: "Алексей".to_string(),        age: 30,        email: "alex@example.com".to_string(),    };

    // Serialización a cadena JSON    let json_string = serde_json::to_string(&user).unwrap();    println!("JSON: {}", json_string);

    // Deserialización de JSON de vuelta a la estructura    let deserialized_user: User = serde_json::from_str(&json_string).unwrap();    println!("Deserializado: {:?}", deserialized_user);}

Resultado de la ejecución:

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

Trabajo con estructuras anidadas

JSON a menudo contiene objetos y arrays anidados. Rust permite modelar fácilmente dichas estructuras:

#[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()],    };

    // Salida JSON bonita con sangría    let pretty_json = serde_json::to_string_pretty(&person).unwrap();    println!("{}", pretty_json);}

Salida:

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

Manejo de errores y campos opcionales

En proyectos reales, los datos pueden estar incompletos. Rust ofrece formas elegantes de manejar estas situaciones:

• Option<T> — para campos opcionales
• Result<T, E> — para manejar errores de análisis
• Atributos de Serde — para configurar el comportamiento de serialización

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

#[derive(Debug, Serialize, Deserialize)]struct Product {    name: String,    price: f64,    #[serde(default)] // Valor por defecto si el campo está ausente    description: Option<String>,    #[serde(skip_serializing_if = "Option::is_none")] // Omitir si es None    discount: