Learn Rust Coding · Lección

Desestructuración

Structs, enums y tuplas

Desestructuración 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.

¿Qué es la desestructuración?

La desestructuración divide un valor compuesto en sus partes mediante un patrón. Funciona con tuplas, structs, enums, arrays y mucho más.

Desestructurar tuplas

Enlace cada elemento de una tupla a su propia variable dentro de un único let.

fn main() {
    let point = (3, 7);
    let (x, y) = point;
    println!("x = {x}, y = {y}");
}

Ignorar partes de una tupla

Use _ para omitir un valor y .. para omitir varios.

fn main() {
    let data = (1, 2, 3, 4);
    let (first, .., last) = data;
    println!("{first} ... {last}");
}

Desestructurar structs

Extraiga campos de un struct por su nombre. Los nombres de las variables enlazadas pueden coincidir con los campos o cambiarse.

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    let Point { x, y } = p;
    println!("{x}, {y}");
}

Cambiar el nombre de campos

Use field: new_name para enlazar un campo de un struct a un nombre de variable diferente.

struct Config {
    width: u32,
    height: u32,
}

fn main() {
    let c = Config { width: 800, height: 600 };
    let Config { width: w, height: h } = c;
    println!("{w} x {h}");
}

Ignorar campos de un struct

.. ignora los campos restantes que no necesita.

struct User {
    name: String,
    age: u32,
    active: bool,
}

fn main() {
    let u = User { name: "Ada".into(), age: 36, active: true };
    let User { name, .. } = u;
    println!("{name}");
}

Desestructurar enums

En un match, desestructure las variantes de un enum para extraer sus datos.

enum Event {
    Click { x: i32, y: i32 },
    Key(char),
}

fn main() {
    let e = Event::Click { x: 5, y: 8 };
    match e {
        Event::Click { x, y } => println!("click at {x},{y}"),
        Event::Key(c) => println!("key {c}"),
    }
}

Desestructuración en parámetros

Los parámetros de las funciones pueden desestructurarse directamente, lo que resulta práctico para tuplas y structs pequeños.

fn distance((x1, y1): (f64, f64), (x2, y2): (f64, f64)) -> f64 {
    ((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt()
}

fn main() {
    println!("{}", distance((0.0, 0.0), (3.0, 4.0)));
}

Desestructuración anidada

Los patrones se pueden anidar libremente, por lo que puede acceder a estructuras profundas en un solo paso.

struct Line {
    start: (i32, i32),
    end: (i32, i32),
}

fn main() {
    let line = Line { start: (0, 0), end: (4, 5) };
    let Line { start: (sx, sy), end: (ex, ey) } = line;
    println!("from {sx},{sy} to {ex},{ey}");
}

Desestructurar arrays y slices

Los arrays y los slices se pueden desestructurar, incluso capturando la parte central con ...

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let [first, .., last] = arr;
    println!("first {first}, last {last}");
}

Desestructuración en bucles for

La desestructuración también funciona en bucles for, lo que resulta perfecto para iterar sobre pares de valores.

fn main() {
    let pairs = [("a", 1), ("b", 2), ("c", 3)];
    for (label, value) in pairs {
        println!("{label} = {value}");
    }
}

Comprobación rápida

¿Cómo se ignoran los campos restantes de un struct al desestructurarlo?

Resumen

Ha aprendido la desestructuración:

Dividir tuplas, structs, enums, arrays y slices
Cambiar el nombre de campos con field: name
Ignorar partes con _ y ..
Desestructurar en let, match y parámetros de funciones
Anidar patrones para realizar extracciones profundas

Preguntas frecuentes

¿La lección «Desestructuración» es gratis?

Sí — el texto completo de «Desestructuració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 «Desestructuración»?

Structs, enums y tuplas 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 «Desestructuració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