Procesamiento de JSON en Rust: bibliotecas serde_json y json

Procesamiento de JSON en Rust: serde_json y trabajo con datos

JSON (JavaScript Object Notation) sigue siendo uno de los formatos de intercambio de datos más populares en el desarrollo web, las API y los archivos de configuración. En el lenguaje Rust, conocido por su rendimiento y seguridad, el trabajo con JSON se implementa a través de un potente ecosistema de crates. La herramienta principal es la biblioteca serde_json, construida sobre el framework de serialización serde. En este artículo, analizaremos en detalle cómo analizar, crear y transformar JSON en Rust, y también consideraremos enfoques alternativos.

1. Instalación y configuración de serde_json

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

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

serde proporciona los traits Serialize y Deserialize, y serde_json proporciona la implementación específica para JSON. Después de agregar los crates, puede importarlos en el código:

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

2. Serialización de estructuras a JSON

Para convertir una estructura de Rust a JSON, debe anotarla con los atributos #[derive(Serialize)]. Veamos un ejemplo con datos de usuario:

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

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

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

El método serde_json::to_string devuelve un Result<String>. Para una salida formateada, use serde_json::to_string_pretty.

3. Deserialización de JSON a estructuras

El proceso inverso: convertir una cadena JSON en una estructura de Rust. Para ello, la estructura debe implementar Deserialize:

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

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

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

Si el JSON contiene campos que no están en la estructura, o viceversa, use los atributos #[serde(default)] o #[serde(skip_serializing_if = "Option::is_none")].

4. Trabajo con JSON arbitrario (Value)

A veces, la estructura de datos no se conoce de antemano. En tales casos, se utiliza la enumeración serde_json::Value, que puede representar cualquier tipo JSON:

use serde_json::Value;

fn main() -> Result<()> {    let data = r#"        {            "name": "Iván",            "age": 35,            "hobbies": ["lectura", "programación"],            "address": null        }"#;

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

    // Acceso a campos    if let Some(name) = v.get("name") {        println!("Nombre: {}", name);    }

    // Extracción de array    if let Some(hobbies) = v.get("hobbies").and_then(|h| h.as_array()) {        for hobby in hobbies {            println!("Pasatiempo: {}", hobby);        }    }

    Ok(())}

Value admite métodos como as_str(), as_u64(), as_array() y otros para la extracción segura de datos.