Learn Rust Coding · Lección

Análisis avanzado de match

Patrones y guards

Análisis avanzado de match 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.

La expresión match

match compara un valor con una serie de patrones y ejecuta la rama de la primera coincidencia. Es una expresión, por lo que devuelve un valor.

fn main() {
    let n = 3;
    let label = match n {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "many",
    };
    println!("{label}");
}

Exhaustividad

Un match debe abarcar todos los valores posibles. El comodín _ captura cualquier valor que no coincida con las ramas anteriores, garantizando la exhaustividad.

fn main() {
    let x = 42;
    match x {
        0 => println!("zero"),
        _ => println!("nonzero"),
    }
}

Coincidir con varios valores

Use | para hacer coincidir varios patrones en una sola rama.

fn main() {
    let c = 'e';
    match c {
        'a' | 'e' | 'i' | 'o' | 'u' => println!("vowel"),
        _ => println!("consonant"),
    }
}

Patrones de rango

Haga coincidir un rango de valores con ..= (inclusivo). Es ideal para agrupar números o caracteres.

fn main() {
    let score = 85;
    let grade = match score {
        90..=100 => 'A',
        80..=89 => 'B',
        70..=79 => 'C',
        _ => 'F',
    };
    println!("Grade: {grade}");
}

Guardas de match

Una guarda es una condición if adicional en una rama. La rama coincide solo cuando el patrón encaja y la guarda es verdadera.

fn main() {
    let pair = (2, -2);
    match pair {
        (x, y) if x + y == 0 => println!("sum is zero"),
        (x, _) if x % 2 == 0 => println!("first is even"),
        _ => println!("no rule"),
    }
}

Vinculación en patrones

Los patrones pueden vincular las partes coincidentes a variables para usarlas en el cuerpo de la rama.

fn main() {
    let msg = Some(7);
    match msg {
        Some(n) => println!("got {n}"),
        None => println!("nothing"),
    }
}

Coincidir con enumeraciones

match resulta especialmente útil con las enumeraciones, sobre todo cuando las variantes contienen datos.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn area(s: Shape) -> f64 {
    match s {
        Shape::Circle(r) => 3.14159 * r * r,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{}", area(Shape::Rectangle(3.0, 4.0)));
}

Ignorar con _ y ..

Use _ para ignorar un único valor y .. para ignorar el resto de una tupla o estructura.

fn main() {
    let triple = (1, 2, 3);
    match triple {
        (first, ..) => println!("first is {first}"),
    }
}

Devolver desde match

Como match es una expresión, puede asignar su resultado o devolverlo directamente. Todas las ramas deben producir el mismo tipo.

fn describe(n: i32) -> &'static str {
    match n.cmp(&0) {
        std::cmp::Ordering::Less => "negative",
        std::cmp::Ordering::Equal => "zero",
        std::cmp::Ordering::Greater => "positive",
    }
}

fn main() {
    println!("{}", describe(-5));
}

El orden de las ramas importa

Las ramas se comprueban de arriba abajo; gana la primera que coincide. Coloque los patrones específicos antes que los generales y deje el comodín para el final.

Vincular rangos con @

Combine un rango con el operador @ para comprobar un valor y conservar su contenido exacto en la misma rama.

fn main() {
    let n = 42;
    match n {
        small @ 0..=9 => println!("single digit: {small}"),
        big @ 10..=99 => println!("two digits: {big}"),
        _ => println!("large"),
    }
}

Comprobación rápida

¿Cuál es el propósito de una guarda de match como (x, y) if x > y?

Resumen

Ha profundizado en match:

Es una expresión exhaustiva que devuelve un valor
| coincide con varios patrones; ..= coincide con rangos
Las guardas añaden condiciones if adicionales
Los patrones vinculan datos; _ y .. ignoran partes
El orden de las ramas importa: gana la primera coincidencia

Preguntas frecuentes

¿La lección «Análisis avanzado de match» es gratis?

Sí — el texto completo de «Análisis avanzado de match» 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 «Análisis avanzado de match»?

Patrones y guards 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 «Análisis avanzado de match»?

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