JSON en Rust para principiantes: análisis y serialización de datos

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción al trabajo con JSON en Rust

JSON (JavaScript Object Notation) es uno de los formatos de intercambio de datos más populares en el desarrollo web, archivos de configuración y API. Si estás aprendiendo Rust y quieres aprender a trabajar eficientemente con JSON, este artículo es para ti. Revisaremos las bibliotecas principales, los principios de análisis y serialización, y analizaremos ejemplos prácticos de código.

En Rust, el ecosistema para trabajar con JSON se construye alrededor del crate serde, un potente framework para la serialización y deserialización de datos. Junto con serde_json, permite transformar fácilmente estructuras de datos a JSON y viceversa. Vamos a entender cómo funciona.

Instalación y configuración de dependencias

Para empezar, crearemos un nuevo proyecto y añadiremos las dependencias necesarias en el archivo Cargo.toml:

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

El crate serde proporciona las macros #[derive(Serialize, Deserialize)], que implementan automáticamente los traits necesarios para tus estructuras. serde_json se encarga directamente del trabajo con el formato JSON.

Análisis de JSON: de cadena a estructura

Supongamos que tenemos una cadena JSON con información de un usuario. Queremos transformarla en una estructura tipada de Rust. Así es como se hace:

use serde::{Deserialize, Serialize};

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

fn main() {    let json_data = r#"        {            "name": "Алексей",            "age": 28,            "email": "alex@example.com",            "is_active": true        }    "#;

    // Análisis de JSON a estructura    let user: User = serde_json::from_str(json_data).expect("Error al analizar JSON");        println!("Usuario: {:?}", user);    println!("Nombre: {}", user.name);    println!("Edad: {}", user.age);}

Observa el atributo #[derive(Debug, Deserialize, Serialize)]. Debug permite imprimir la estructura en la consola, mientras que Deserialize y Serialize permiten transformar datos a JSON y viceversa.

Manejo de objetos anidados

JSON a menudo contiene objetos anidados. Veamos un ejemplo con la dirección de un usuario:

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

#[derive(Debug, Deserialize, Serialize)]struct User {    name: String,    age: u32,    address: Address,}

fn main() {    let json_data = r#"        {            "name": "Мария",            "age": 32,            "address": {                "city": "Москва",                "street": "Тверская, 15",                "zip_code": "101000"            }        }    "#;

    let user: User = serde_json::from_str(json_data).unwrap();    println!("Ciudad: {}", user.address.city);}

Trabajo con arrays JSON

Los arrays en JSON se transforman en Vec u otras colecciones de Rust:

use serde::Deserialize;

#[derive(Debug, Deserialize)]struct Product {    id: u32,    name: String,    price: f64,}

fn main() {    let json_array = r#"        [            {"id": 1, "name": "Ноутбук", "price": 75000.50},            {"id": 2, "name": "Мышь", "price": 1500.00},            {"id": 3, "name": "Клавиатура", "price": 3500.00}        ]    "#;

    let products: Vec<Product> = serde_json::from_str(json_array).unwrap();        for product in &products {        println!("{}: {} руб.", product.name, product.price);    }}