Usar match con variantes de enum
Use match para gestionar cada caso
Usar match con variantes de enum 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.
Conozca la expresión match
La expresión match compara un valor con una serie de patrones y ejecuta el código correspondiente al primero que encaja.
Es el complemento natural de los enums: puede gestionar cada variante en su propio brazo.
enum Light {
Red,
Green,
}
fn action(l: Light) {
match l {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}
}Anatomía de un brazo de match
Cada brazo tiene la forma pattern => expression, y los brazos se separan mediante comas.
El patrón indica qué se debe comparar, y la expresión posterior a => se ejecuta cuando hay coincidencia. Aquí, el patrón es una única variante del enum.
match light {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}Un programa completo con matching
Aquí tiene un programa completo que aplica matching a un semáforo e imprime una instrucción.
Ejecútelo y cambie la variante en main para ver cómo se ejecuta un brazo diferente.
enum TrafficLight {
Red,
Yellow,
Green,
}
fn main() {
let light = TrafficLight::Yellow;
match light {
TrafficLight::Red => println!("Stop"),
TrafficLight::Yellow => println!("Slow down"),
TrafficLight::Green => println!("Go"),
}
}match debe ser exhaustivo
Rust exige que match cubra todas las variantes posibles. Si olvida alguna, el programa no se compilará.
Esta es una potente característica de seguridad: si más adelante añade una variante, el compilador le recordará todos los lugares que deben gestionarla.
// This would FAIL to compile because
// the Green case is missing:
// match light {
// Light::Red => println!("Stop"),
// }El patrón comodín con _
Cuando no quiera enumerar todas las variantes, use el guion bajo _ como patrón comodín. Coincide con cualquier elemento que no se haya gestionado anteriormente.
Colóquelo al final, ya que los brazos se prueban en orden.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let c = Coin::Dime;
match c {
Coin::Penny => println!("1 cent"),
_ => println!("Some other coin"),
}
}match devuelve un valor
match es una expresión, por lo que produce un valor que puede guardar en una variable.
Todos los brazos deben devolver el mismo tipo. Observe que aquí no hay un punto y coma después de la expresión de cada brazo.
enum Coin {
Penny,
Quarter,
}
fn main() {
let coin = Coin::Quarter;
let cents = match coin {
Coin::Penny => 1,
Coin::Quarter => 25,
};
println!("{} cents", cents);
}Cuerpos de brazos en varias líneas
Un brazo puede ejecutar varias instrucciones si las encierra entre llaves { ... }.
La última expresión dentro de las llaves es el valor que produce el brazo.
match light {
Light::Red => {
println!("Caution!");
println!("Stop the car");
}
Light::Green => println!("Go"),
}Combinar patrones con |
Use la barra vertical | para hacer coincidir varias variantes en un solo brazo. Se lee como «o».
Así evita repetir el mismo cuerpo para variantes que deben comportarse de forma idéntica.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let c = Coin::Nickel;
match c {
Coin::Penny | Coin::Nickel => println!("Small coin"),
_ => println!("Bigger coin"),
}
}match frente a if/else
Podría encadenar if / else if para comprobar las variantes, pero match es más claro y seguro.
Con match, el compilador verifica que haya gestionado todos los casos. Una cadena de instrucciones if no ofrece esa garantía.
Hacer matching e imprimir a la vez
Un patrón habitual consiste en convertir una variante en una cadena descriptiva e imprimirla.
Ejecute este programa y cambie la dirección elegida para ver el mensaje correspondiente.
enum Direction {
North,
South,
East,
West,
}
fn main() {
let d = Direction::West;
let name = match d {
Direction::North => "North",
Direction::South => "South",
Direction::East => "East",
Direction::West => "West",
};
println!("Heading {}", name);
}El orden importa
Los brazos se comprueban de arriba abajo, y gana la primera coincidencia. Los demás se omiten.
Por eso el comodín _ debe ir al final: si estuviera primero, capturaría todos los valores antes de que pudieran ejecutarse los brazos específicos.
Comprobación rápida
Compruebe su comprensión de match.
Resumen
Ha aprendido que match compara un valor con patrones y ejecuta el primer brazo que coincide.
Debe ser exhaustivo, puede usar _ como comodín, combinar variantes con | y devolver un valor porque es una expresión. A continuación, aprenderá a asignar sus propios datos a las variantes de un enum.
Preguntas frecuentes
¿La lección «Usar match con variantes de enum» es gratis?
Sí — el texto completo de «Usar match con variantes de enum» 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 «Usar match con variantes de enum»?
Use match para gestionar cada caso 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 «Usar match con variantes de enum»?
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
- Definir su primer enum
- Usar match con variantes de enum
- Enums con datos
- Guardas y vinculaciones en match