Vectores de structs
Almacene datos complejos en un Vec
Vectores de structs 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.
Por qué usar vectores de structs
Los vectores pueden contener cualquier tipo único, incluidos sus propios structs. Un Vec<Person> almacena varias personas en orden, lo que resulta ideal para listas de registros como usuarios, artículos o puntuaciones.
Esto combina estructuras de datos personalizadas con una lista que puede crecer.
Definir un struct
Primero, defina el struct que quiere almacenar. Este Person tiene un nombre y una edad.
La línea #[derive(Debug)] permite imprimir una persona con {:?}, lo que resulta útil para vectores completos.
#[derive(Debug)]
struct Person {
name: String,
age: u32,
}Construir el vector
Cree instancias del struct y, después, reúnalas en una macro vec!. El tipo del vector se convierte automáticamente en Vec<Person>.
Use {:?} para imprimir todos los registros a la vez.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 25 },
];
println!("{:?}", people);
}Añadir structs con push
También puede empezar con un vector vacío y usar push para añadir structs uno a uno. El vector debe ser mut para poder crecer.
Este patrón resulta adecuado cuando los registros llegan con el tiempo, por ejemplo, a partir de la entrada del usuario.
#[derive(Debug)]
struct Item { name: String }
fn main() {
let mut cart = Vec::new();
cart.push(Item { name: String::from("Pen") });
cart.push(Item { name: String::from("Mug") });
println!("{:?}", cart);
}Recorrer registros
Recorra &people para leer cada struct sin tomar su propiedad. Dentro del bucle, puede acceder a los campos con la notación de punto, como en p.name.
Esto imprime una línea descriptiva para cada registro.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 25 },
];
for p in &people {
println!("{} is {}", p.name, p.age);
}
}Leer un campo
Use un índice del vector para acceder a un struct y, después, emplee la notación de punto para acceder a su campo. Por tanto, people[0].name proporciona el nombre de la primera persona.
Recuerde que los índices empiezan en 0 y que acceder fuera de rango provoca un pánico.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
];
println!("name: {}", people[0].name);
}Modificar un campo
Para editar un registro, el vector debe ser mut. Después, acceda al struct mediante un índice y asigne un valor a su campo, como en people[0].age = 31.
Esto actualiza los datos almacenados directamente.
struct Person { name: String, age: u32 }
fn main() {
let mut people = vec![
Person { name: String::from("Ann"), age: 30 },
];
people[0].age = 31;
println!("{}", people[0].age);
}Sumar un campo
Los iteradores pueden extraer un campo de cada registro. Aquí, iter().map(|p| p.age).sum() suma todas las edades.
El paso map convierte cada persona únicamente en su edad antes de realizar la suma.
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
let total: u32 = people.iter().map(|p| p.age).sum();
println!("total age = {}", total);
}Filtrar registros
Use iter().filter(...) para conservar los registros que cumplen una regla. El cierre devuelve un bool para cada struct.
Aquí contamos cuántas personas tienen al menos 30 años.
struct Person { name: String, age: u32 }
fn main() {
let people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
let adults = people.iter().filter(|p| p.age >= 30).count();
println!("adults: {}", adults);
}Ordenar por un campo
Ordene los registros por un campo con sort_by_key. Proporciónele un cierre que devuelva el valor por el que desea ordenar, como la edad.
El vector debe ser mut porque la ordenación lo reorganiza.
#[derive(Debug)]
struct Person { name: String, age: u32 }
fn main() {
let mut people = vec![
Person { name: String::from("Ann"), age: 30 },
Person { name: String::from("Bo"), age: 20 },
];
people.sort_by_key(|p| p.age);
println!("{:?}", people);
}Contar registros
El número de structs almacenados es simplemente len(), igual que en cualquier vector. Esto indica cuántos registros contiene actualmente.
Combínelo con is_empty() para comprobar que hay elementos antes de leer el primer registro.
struct Item { name: String }
fn main() {
let cart = vec![
Item { name: String::from("Pen") },
Item { name: String::from("Mug") },
];
println!("items: {}", cart.len());
}Comprobación rápida
Compruebe su comprensión de los vectores de structs.
Resumen
Ha almacenado structs en un Vec, lo ha construido con vec! y push, y ha leído o editado campos mediante índices y bucles.
También ha sumado, filtrado, ordenado por un campo y contado registros. Ahora puede gestionar listas de datos estructurados con vectores.
Preguntas frecuentes
¿La lección «Vectores de structs» es gratis?
Sí — el texto completo de «Vectores de structs» 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 «Vectores de structs»?
Almacene datos complejos en un Vec 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 «Vectores de structs»?
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
- Crear y rellenar vectores
- Indexar e iterar
- Aumentar y reducir el tamaño
- Vectores de structs