0Pricing
Learn Rust Coding · Lección

Coincidencia de patrones avanzada

Domine las expresiones `match` y otras construcciones de coincidencia de patrones para gestionar variantes de datos de forma concisa y exhaustiva.

Coincidencia de patrones avanzada es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 3 de 3. 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 3 lecciones en total.

Descubrir el pattern matching

¡Le damos la bienvenida al mundo del pattern matching en Rust! Esta potente característica permite controlar el flujo del programa según la estructura de los datos.

En lugar de limitarse a comprobar la igualdad, puede descomponer valores, extraer componentes y ejecutar código específico para distintas formas de datos.

  • Es como una instrucción if/else o switch con superpoderes.
  • Garantiza la exhaustividad: debe gestionar todos los patrones posibles.
  • Hace que el código sea más legible y robusto.

Conceptos básicos de la expresión `match`

El núcleo del pattern matching es la expresión match. Toma un valor y lo compara con una serie de patrones. ¡Gana el primer patrón que coincide!

Cada «brazo» de una expresión match consta de un patrón y del código que se ejecutará si dicho patrón coincide.

enum Direction {
  North,
  East,
  South,
  West,
}

fn main() {
  let my_direction = Direction::North;

  match my_direction {
    Direction::North => println!("Going up!"),
    Direction::East => println!("Going right!"),
    Direction::South => println!("Going down!"),
    Direction::West => println!("Going left!"),
  }
}

Coincidir con literales y rangos

Puede comparar valores literales específicos (números, caracteres y booleanos) o definir rangos mediante ..=. El operador | permite comparar varios patrones con un solo brazo.

Recuerde que los patrones se comprueban en orden y se utiliza la primera coincidencia.

fn main() {
  let x = 7;

  match x {
    1 => println!("It's one!"),
    2 | 3 => println!("It's two or three!"),
    4..=8 => println!("It's between four and eight!"),
    _ => println!("It's something else!"), // Catch-all
  }

  let character = 'b';
  match character {
    'a'..='e' => println!("Early letter"),
    _ => println!("Other letter"),
  }
}

Desestructurar estructuras

El pattern matching resulta especialmente útil al desestructurar tipos de datos complejos, como las estructuras. Puede extraer campos individuales directamente en variables dentro del brazo de match.

Esto permite acceder a los datos de una estructura de forma clara y concisa, especialmente al comparar valores específicos de sus campos.

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

fn main() {
  let p = Point { x: 0, y: 7 };

  match p {
    Point { x, y: 0 } => println!("On the X axis at {}", x),
    Point { x: 0, y } => println!("On the Y axis at {}", y),
    Point { x, y } => println!("Not on an axis: ({}, {})", x, y),
  }
}

Desestructurar enumeraciones con datos

Las enumeraciones de Rust pueden contener datos asociados. El pattern matching es la forma principal de extraer estos datos de una variante de enumeración.

Puede desestructurar los datos directamente en variables nuevas, lo que facilita trabajar con el contenido de cada variante.

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
  match msg {
    Message::Quit => println!("Quit message."),
    Message::Move { x, y } => {
      println!("Move to x: {}, y: {}", x, y);
    }
    Message::Write(text) => println!("Text message: {}", text),
    Message::ChangeColor(r, g, b) => {
      println!("Color: R:{}, G:{}, B:{}", r, g, b);
    }
  }
}

fn main() {
  process_message(Message::Move { x: 10, y: 20 });
  process_message(Message::Write(String::from("Hello!")));
}

El patrón comodín `_`

El patrón especial _ (guion bajo) actúa como un comodín. Coincide con cualquier valor, pero no lo vincula.

Es útil cuando necesita cubrir todas las posibilidades para garantizar la exhaustividad, pero no le importa el valor concreto que coincide con un brazo determinado.

fn main() {
  let some_value = Some(5);
  let absent_value: Option<i32> = None;

  match some_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("Something else!"), // Matches None too
  }

  match absent_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("No value here!"),
  }
}

`if let` para patrones individuales

A veces, solo le interesa hacer coincidir un patrón específico y quiere ignorar todos los demás. En esos casos, if let es una alternativa más concisa que una expresión match completa.

En esencia, indica: «si este patrón coincide, haga esto; de lo contrario, no haga nada (o ejecute un bloque else opcional)».

fn main() {
  let config_max = Some(3u8);
  let none_value: Option<u8> = None;

  if let Some(max) = config_max {
    println!("Max configured to be: {}", max);
  }

  if let Some(val) = none_value {
    println!("This won't print: {}", val);
  } else {
    println!("No value found!");
  }
}

`while let` para bucles condicionales

Al igual que if let, while let permite repetir un bucle mientras un patrón siga coincidiendo.

Es muy útil para procesar elementos de colecciones como Vecs cuando desea continuar hasta que no queden más elementos coincidentes (por ejemplo, hasta que pop() devuelva None).

fn main() {
  let mut stack = vec![1, 2, 3];

  while let Some(top) = stack.pop() {
    println!("Popped: {}", top);
  }

  println!("Stack is empty now.");
}

Guardas de match: añadir condiciones

Puede añadir una condición if adicional, denominada guarda de match, a un brazo de match. El patrón debe coincidir Y la condición de la guarda debe ser verdadera para que se ejecute ese brazo.

Esto permite un control más preciso dentro de un patrón sin necesidad de crear más variantes de enumeración.

fn main() {
  let num = Some(4);

  match num {
    Some(x) if x % 2 == 0 => println!("Even number: {}", x),
    Some(x) if x < 5 => println!("Small odd number: {}", x),
    Some(x) => println!("Any other number: {}", x),
    None => println!("No number"),
  }
}

Desafío de pattern matching

Considere el siguiente fragmento de código Rust. ¿Cuáles de las siguientes afirmaciones sobre la expresión match y su resultado son VERDADERAS?

enum Status {
  Loading,
  Success(u32),
  Error(String),
}

fn process_status(s: Status) {
  match s {
    Status::Success(code) if code > 200 => println!("Success with high code: {}", code),
    Status::Success(code) => println!("Success with code: {}", code),
    Status::Error(msg) => println!("Failed: {}", msg),
    _ => println!("Status unknown or loading..."),
  }
}

fn main() {
  process_status(Status::Success(201));
  process_status(Status::Error(String::from("Network issue")));
  process_status(Status::Loading);
  process_status(Status::Success(200));
}

Repaso: dominar los patrones

¡Ha explorado el increíble poder del pattern matching en Rust! Es un concepto fundamental para escribir código claro, conciso y seguro.

  • Las expresiones match proporcionan un control exhaustivo del flujo según la estructura de los datos.
  • Puede comparar literales y rangos, y utilizar comodines (_).
  • La desestructuración permite extraer valores de estructuras y enumeraciones directamente.
  • if let y while let ofrecen formas concisas de comparar patrones individuales.
  • Las guardas de match añaden lógica condicional a los brazos de match.

Siga practicando estos patrones; ¡son esenciales para escribir Rust idiomático!

Preguntas frecuentes

¿La lección «Coincidencia de patrones avanzada» es gratis?

Sí — el texto completo de «Coincidencia de patrones avanzada» 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 3 lecciones en total.

¿Qué aprenderé en «Coincidencia de patrones avanzada»?

Domine las expresiones `match` y otras construcciones de coincidencia de patrones para gestionar variantes de datos de forma concisa y exhaustiva. 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 3 de 3.

¿Cuánto tiempo toma la lección «Coincidencia de patrones avanzada»?

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

  1. Definición y uso de structs
  2. Enums para tipos personalizados
  3. Coincidencia de patrones avanzada
← Volver a Learn Rust Coding