Control de Flujo

## Objetivos de Aprendizaje - Dominar las sentencias condicionales (if-else) - Trabajar con bucles (loop, while, for) - Usar expresiones match - Comprender la coincidencia de patrones ## Expresiones if-else ### if Basico ```rust fn main() { let x = 5; if x > 0 { println!("x is positive"); } } ``` ### if-else ```rust fn main() { let x = -5; if x > 0 { println!("x is positive"); } else { println!("x is not positive"); } } ``` ### if-else if-else ```rust fn main() { let x = 0; if x > 0 { println!("positive"); } else if x < 0 { println!("negative"); } else { println!("zero"); } } ``` ### if como Expresion ```rust fn main() { let x = 5; let sign = if x > 0 { "positive" } else { "non-positive" }; println!("{}", sign); // positive // Con multiples else if let grade = if x >= 90 { "A" } else if x >= 80 { "B" } else if x >= 70 { "C" } else { "F" }; } ``` ### Operadores de Comparacion ```rust // == Igual // != No igual // > Mayor que // < Menor que // >= Mayor o igual que // <= Menor o igual que ``` ### Operadores Logicos ```rust // && Y logico // || O logico // ! No logico fn main() { let x = 5; let y = 10; if x > 0 && y > 0 { println!("Both positive"); } if x > 0 || y > 0 { println!("At least one is positive"); } if !(x == 0) { println!("x is not zero"); } } ``` ## Expresiones de Bucle ### loop (Bucle Infinito) ```rust fn main() { let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; // Devolver valor del loop } }; println!("Result: {}", result); // 20 } ``` ### Bucle while ```rust fn main() { let mut number = 3; while number != 0 { println!("{}", number); number -= 1; } println!("LIFTOFF!!!"); } ``` ### Bucle for ```rust fn main() { // Iterar sobre rango for i in 0..5 { println!("{}", i); // 0, 1, 2, 3, 4 } // Rango inclusivo for i in 0..=5 { println!("{}", i); // 0, 1, 2, 3, 4, 5 } // Iterar sobre arreglo let arr = [10, 20, 30]; for element in arr { println!("{}", element); } // Con indice let arr = [10, 20, 30]; for i in 0..arr.len() { println!("{}: {}", i, arr[i]); } } ``` ### for con Rango y paso ```rust fn main() { // Rango for i in 1..=5 { println!("{}", i); } // Rev (inverso) for i in (1..=5).rev() { println!("{}", i); // 5, 4, 3, 2, 1 } // Paso de 2 for i in (0..=10).step_by(2) { println!("{}", i); // 0, 2, 4, 6, 8, 10 } } ``` ### Etiquetas de Bucle ```rust fn main() { 'outer: for i in 1..=3 { 'inner: for j in 1..=3 { if j == 2 { continue; // Saltar j = 2 } if i == 2 && j == 1 { break 'outer; // Romper bucle exterior } println!("{} {}", i, j); } } } ``` ## Expresiones match ### match Basico ```rust fn main() { let x = 1; match x { 1 => println!("one"), 2 => println!("two"), 3 => println!("three"), _ => println!("anything else"), } } ``` ### match con Multiples Brazos ```rust fn main() { let x = 2; match x { 1 | 2 | 3 => println!("one, two, or three"), 4..=6 => println!("four, five, or six"), _ => println!("something else"), } } ``` ### match con Rangos ```rust fn main() { let score = 85; let grade = match score { 90..=100 => "A", 80..=89 => "B", 70..=79 => "C", 60..=69 => "D", _ => "F", }; println!("Grade: {}", grade); } ``` ### match con Patron let ```rust fn main() { let msg = Some("hello"); match msg { Some(text) => println!("{}", text), None => println!("No message"), } // Equivalente con if let if let Some(text) = msg { println!("{}", text); } } ``` ### match con if guard ```rust fn main() { let x = Some(5); match x { Some(n) if n > 0 => println!("positive: {}", n), Some(n) if n == 0 => println!("zero"), Some(n) => println!("negative: {}", n), None => println!("none"), } } ``` ### match con Desestructuracion ```rust fn main() { let point = (3, 5); match point { (0, 0) => println!("origin"), (x, 0) => println!("on x-axis: {}", x), (0, y) => println!("on y-axis: {}", y), (x, y) => println!("({}, {})", x, y), } } ``` ### match con Enum ```rust enum Color { Red, Green, Blue, RGB(u8, u8, u8), } fn main() { let color = Color::RGB(255, 0, 0); match color { Color::Red => println!("Red"), Color::Green => println!("Green"), Color::Blue => println!("Blue"), Color::RGB(r, g, b) => println!("RGB({}, {}, {})", r, g, b), } } ``` ## Expresiones if let ### if let Basico ```rust fn main() { let msg = Some(42); if let Some(n) = msg { println!("Number is {}", n); } else { println!("No number"); } } ``` ### if let con else ```rust fn main() { let msg: Option = None; if let Some(n) = msg { println!("Number is {}", n); } else { println!("No number provided"); } } ``` ### if let con enum ```rust enum Message { Quit, Move { x: i32, y: i32 }, Write(String), } fn main() { let msg = Message::Move { x: 10, y: 20 }; if let Message::Move { x, y } = msg { println!("Move to ({}, {})", x, y); } } ``` ## Expresiones while let ```rust fn main() { let mut stack = vec![1, 2, 3]; while let Some(top) = stack.pop() { println!("Popped: {}", top); } } ``` ## Combinando Patrones ```rust fn main() { let result: Result = Ok(42); match result { Ok(n) if n > 0 => println!("positive: {}", n), Ok(n) => println!("zero or negative: {}", n), Err(e) => println!("Error: {}", e), } } ``` ## Resumen - if-else para ejecucion condicional - if puede usarse como expresion (devuelve valor) - loop crea bucle infinito, break puede devolver valor - bucle while con condicion - bucle for sobre rangos, iteradores, colecciones - Etiquetas de bucle para romper bucles anidados - match es coincidencia de patrones exhaustiva - Rangos: `a..b` (exclusivo), `a..=b` (inclusivo) - `|` combina patrones en brazo de match - if let y while let para coincidencia de patron unico