Learn Rust Coding · Lección

Serialización y deserialización

Macros derive

Serialización y deserialización es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué es Serde?

Serde (SERialize/DEserialize) es el framework de Rust para convertir estructuras de datos desde y hacia formatos como JSON, YAML y otros.

Núcleo independiente del formato y crates para cada formato
Basado en macros derive

Añadir serde

Añada serde con la característica derive, junto con un crate de formato como serde_json. Esto modifica Cargo.toml.

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

Derivar los traits

Anote una estructura con #[derive(Serialize, Deserialize)] para hacerla convertible. Cada campo debe poder serializarse por sí mismo.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
}

Serialize significa convertir a un formato

Serialize convierte un valor en bytes o texto en algún formato. La estructura no sabe qué formato se usará; esa decisión corresponde al crate del formato.

Deserialize significa convertir desde un formato

Deserialize analiza texto o bytes y los convierte de nuevo en un valor de Rust, validando durante el proceso los tipos y los campos obligatorios.

Modelar la serialización manualmente

Para entender mejor el concepto, aquí tiene un serializador escrito manualmente para una estructura sencilla. serde genera código similar por usted.

struct User { id: u32, name: String }

fn serialize(u: &User) -> String {
    format!("id={};name={}", u.id, u.name)
}

fn main() {
    let u = User { id: 7, name: "Alice".to_string() };
    println!("{}", serialize(&u));
}

Modelar la deserialización manualmente

Y este es el proceso inverso: analizar texto para convertirlo de nuevo en la estructura. El código generado por serde lo hace de forma sólida en distintos formatos.

struct User { id: u32, name: String }

fn deserialize(s: &str) -> User {
    let parts: Vec<&str> = s.split(',').collect();
    let id = parts[0].parse().unwrap();
    let name = parts[1].to_string();
    User { id, name }
}

fn main() {
    let u = deserialize("42,Bob");
    println!("{} {}", u.id, u.name);
}

Derivar en enums

Los enums también funcionan. De forma predeterminada, cada variante se serializa con su nombre y los datos que contenga quedan anidados.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
enum Shape {
    Circle { radius: f64 },
    Square { side: f64 },
}

Estructuras anidadas

serde recorre las estructuras anidadas automáticamente. Una estructura que contenga otras estructuras derivadas o Vec funciona directamente.

use serde::{Serialize, Deserialize};

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

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    addresses: Vec<Address>,
}

Solo Serialize o solo Deserialize

Puede derivar un solo trait. El tipo de respuesta de una API podría implementar únicamente Serialize; el tipo de una solicitud entrante, únicamente Deserialize.

use serde::Serialize;

#[derive(Serialize)]
struct ApiResponse {
    status: u16,
    message: String,
}

Requisitos para derive

El tipo de cada campo debe implementar el trait que derive. Los tipos estándar y las colecciones ya lo implementan; los tipos personalizados necesitan su propio derive.

use serde::Serialize;

#[derive(Serialize)]
struct Inner { x: i32 }

#[derive(Serialize)]
struct Outer { inner: Inner }

Comprobación rápida

Compruebe su comprensión de la serialización y la deserialización.

Resumen

Ha aprendido los conceptos básicos de serde:

serde es un framework de (des)serialización independiente del formato
#[derive(Serialize, Deserialize)] genera el código de conversión
Funciona con estructuras, enums y tipos anidados
Puede derivar una sola dirección cuando sea apropiado

Siguiente: trabajar con JSON mediante serde_json.

Preguntas frecuentes

¿La lección «Serialización y deserialización» es gratis?

Sí — el texto completo de «Serialización y deserialización» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Serialización y deserialización»?

Macros derive Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Serialización y deserialización»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding