Otros formatos
TOML, YAML y bincode
Otros formatos es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 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.
Más allá de JSON
El núcleo de serde no depende del formato, por lo que la misma estructura derivada funciona con muchos formatos; solo tiene que cambiar el crate del formato.
- TOML para la configuración
- YAML para datos fáciles de leer
- bincode para datos binarios compactos
Una estructura, muchos formatos
Define la estructura una sola vez. Cada crate de formato proporciona sus propios equivalentes de to_string / from_str sobre las mismas implementaciones de Serialize / Deserialize.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct Config {
name: String,
port: u16,
}TOML
TOML es popular para la configuración (el propio Cargo.toml lo utiliza). El crate toml lo serializa y analiza.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_toml(c: &Config) -> String {
toml::to_string(c).unwrap()
}Analizar TOML
Lea una configuración TOML y conviértala de nuevo en su estructura con toml::from_str.
use serde::Deserialize;
#[derive(Deserialize)]
struct Config { name: String, port: u16 }
fn parse(s: &str) -> Config {
toml::from_str(s).unwrap()
}YAML
YAML es adecuado para datos editados por personas y con anidamiento. Utilice un crate como serde_yaml con la misma estructura de API.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_yaml(c: &Config) -> String {
serde_yaml::to_string(c).unwrap()
}bincode
bincode es un formato binario compacto, ideal para el almacenamiento en caché o el envío por la red cuando el tamaño y la velocidad son importantes y ninguna persona necesita leerlo.
use serde::Serialize;
#[derive(Serialize)]
struct Config { name: String, port: u16 }
fn to_bytes(c: &Config) -> Vec<u8> {
bincode::serialize(c).unwrap()
}Elegir un formato
Elija según el público:
- Configuración anidada para personas: TOML o YAML
- API web: JSON
- Almacenamiento o transporte binario interno: bincode
Modelar la elección del formato
La decisión consiste simplemente en asignar cada caso de uso a un formato. Este ejemplo ejecutable representa esa lógica de selección.
fn pick_format(use_case: &str) -> &str {
match use_case {
"config" => "TOML",
"api" => "JSON",
"cache" => "bincode",
_ => "JSON",
}
}
fn main() {
println!("{}", pick_format("config"));
println!("{}", pick_format("cache"));
println!("{}", pick_format("api"));
}Recorrido de ida y vuelta de bytes
Los formatos binarios permiten hacer un recorrido de ida y vuelta: serialice a bytes y después vuelva a deserializar en la misma estructura. Este ejemplo ejecutable representa conceptualmente un recorrido de ida y vuelta basado en la longitud de los bytes.
fn encode(name: &str) -> Vec<u8> {
name.as_bytes().to_vec()
}
fn decode(bytes: &[u8]) -> String {
String::from_utf8(bytes.to_vec()).unwrap()
}
fn main() {
let bytes = encode("Alice");
println!("len={}", bytes.len());
println!("back={}", decode(&bytes));
}Particularidades específicas de cada formato
Los formatos difieren en sus capacidades. TOML no permite valores nulos y necesita tablas para el anidamiento; YAML admite anclas; bincode no se describe a sí mismo, por lo que ambos extremos deben compartir el tipo.
Los atributos siguen siendo aplicables
Los atributos #[serde(...)] que ha aprendido (rename, default, skip) funcionan en todos los formatos, ya que operan en la capa de serde, no en la capa del formato.
use serde::Serialize;
#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
struct Config { max_connections: u32 }Comprobación rápida
Compruebe su comprensión de otros formatos.
Resumen
Ha aprendido sobre otros formatos de serde:
- Una estructura derivada funciona con TOML, YAML, JSON y bincode
- Cada crate de formato ofrece API conocidas de estilo
to_string/from_str - Elija según el público: configuración, API o almacenamiento binario
- Los atributos de serde se aplican a todos los formatos
Con esto concluyen el curso de Serde y la serie de Rust.
Preguntas frecuentes
¿La lección «Otros formatos» es gratis?
Sí — el texto completo de «Otros formatos» 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 «Otros formatos»?
TOML, YAML y bincode 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 4 de 4.
¿Cuánto tiempo toma la lección «Otros formatos»?
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.