Trabajo con JSON
serde_json
Trabajo con JSON es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 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.
El crate serde_json
serde_json es la implementación del formato JSON para serde. Proporciona funciones para convertir entre valores de Rust y texto JSON.
to_string/from_strpara textoValuepara JSON dinámico
De estructura a cadena JSON
serde_json::to_string serializa cualquier valor Serialize en una cadena JSON.
use serde::Serialize;
#[derive(Serialize)]
struct User { id: u32, name: String }
fn main() {
let u = User { id: 1, name: "Alice".to_string() };
let json = serde_json::to_string(&u).unwrap();
println!("{}", json);
}De cadena JSON a estructura
serde_json::from_str analiza JSON y lo convierte en un valor tipado. Devuelve un Result para que pueda gestionar las entradas con formato incorrecto.
use serde::Deserialize;
#[derive(Deserialize, Debug)]
struct User { id: u32, name: String }
fn main() {
let data = r#"{"id":1,"name":"Alice"}"#;
let u: User = serde_json::from_str(data).unwrap();
println!("{:?}", u);
}Formato legible
Use to_string_pretty para generar JSON indentado y fácil de leer, práctico para archivos de configuración y depuración.
use serde::Serialize;
#[derive(Serialize)]
struct Cfg { debug: bool, level: u8 }
fn main() {
let c = Cfg { debug: true, level: 3 };
println!("{}", serde_json::to_string_pretty(&c).unwrap());
}La macro json!
Construya JSON directamente con la macro json!, que produce un Value sin necesidad de definir una estructura.
use serde_json::json;
fn main() {
let v = json!({
"name": "Alice",
"roles": ["admin", "user"]
});
println!("{}", v);
}El tipo Value
serde_json::Value es un enum que representa cualquier nodo JSON: null, booleano, número, cadena, array u objeto. Úselo cuando no conozca la estructura.
use serde_json::Value;
fn main() {
let data = r#"{"name":"Bob","age":30}"#;
let v: Value = serde_json::from_str(data).unwrap();
println!("{}", v["name"]);
println!("{}", v["age"]);
}Leer Value de forma segura
El acceso mediante índice devuelve un Value; use métodos de acceso como as_str o as_i64, que devuelven Option, para leer datos tipados de forma segura.
use serde_json::Value;
fn name_of(v: &Value) -> Option<&str> {
v.get("name")?.as_str()
}Modelar el acceso a JSON en Rust básico
Leer un valor mediante una clave, con un valor alternativo cuando no existe, refleja la forma de consultar un objeto Value. Aquí se muestra con un HashMap.
use std::collections::HashMap;
fn main() {
let mut obj: HashMap<&str, &str> = HashMap::new();
obj.insert("name", "Alice");
let name = obj.get("name").copied().unwrap_or("unknown");
let city = obj.get("city").copied().unwrap_or("unknown");
println!("name={} city={}", name, city);
}Bytes y writers
Para mejorar el rendimiento, to_vec serializa en bytes y to_writer transmite directamente a cualquier io::Write, como un archivo o un socket.
use serde::Serialize;
#[derive(Serialize)]
struct Msg { text: String }
fn to_bytes(m: &Msg) -> Vec<u8> {
serde_json::to_vec(m).unwrap()
}Gestionar errores de análisis
from_str devuelve un Result. Compruebe el error para mostrar al usuario un mensaje útil en lugar de provocar un panic.
use serde::Deserialize;
#[derive(Deserialize)]
struct User { id: u32 }
fn parse(s: &str) -> String {
match serde_json::from_str::<User>(s) {
Ok(u) => format!("id {}", u.id),
Err(e) => format!("invalid JSON: {}", e),
}
}Convertir entre Value y estructuras
serde_json::from_value y to_value convierten entre una estructura tipada y el Value dinámico cuando necesita ambos.
use serde::Deserialize;
use serde_json::json;
#[derive(Deserialize)]
struct User { name: String }
fn main() {
let v = json!({"name": "Eve"});
let u: User = serde_json::from_value(v).unwrap();
println!("{}", u.name);
}Comprobación rápida
Compruebe su comprensión del trabajo con JSON.
Resumen
Ha aprendido a gestionar JSON con serde_json:
to_string/from_strconvierten entre estructuras y texto JSONto_string_prettyaplica un formato legible- La macro
json!yValuepermiten trabajar con JSON dinámico - Use métodos de acceso y
Resultpara leer y analizar datos de forma segura
Siguiente: personalizar la serialización con atributos de campo.
Preguntas frecuentes
¿La lección «Trabajo con JSON» es gratis?
Sí — el texto completo de «Trabajo con JSON» 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 «Trabajo con JSON»?
serde_json 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 2 de 4.
¿Cuánto tiempo toma la lección «Trabajo con JSON»?
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.