Nivel 1 · Fundamentos· Lección 3 de 10 · 20 min
Funciones y control de flujo
Expresiones frente a sentencias, funciones, if, bucles y por qué casi todo en Rust produce un valor.
Funciones
fn add(a: i32, b: i32) -> i32 {
a + b
}
fn main() {
println!("{}", add(2, 3));
}
Los tipos de los parámetros se escriben siempre. El tipo de retorno va después de ->. Y fíjate en que no hay return ni punto y coma después de a + b: ese es el corazón de esta lección.
Expresiones y sentencias
Rust es un lenguaje orientado a expresiones. Una expresión se evalúa y produce un valor. Una sentencia realiza una acción y no se evalúa a nada útil.
a + bes una expresión.let x = 5;es una sentencia.- Un bloque
{ ... }es una expresión: su valor es el de su última expresión, escrita sin punto y coma. - Añadir un punto y coma a una expresión la convierte en sentencia y descarta su valor.
fn main() {
let y = {
let x = 3;
x * x + 1 // sin punto y coma: este es el valor del bloque
};
println!("{y}");
}
El cuerpo de una función es un bloque, así que su última expresión es el valor de retorno. return existe para salir antes de tiempo:
fn describe(n: i32) -> &'static str {
if n < 0 {
return "negative";
}
if n == 0 { "zero" } else { "positive" }
}
fn main() {
println!("{} {} {}", describe(-5), describe(0), describe(9));
}
if es una expresión
No hay operador ternario porque if ya lo es. La condición debe ser un bool: Rust no tiene valores «verdaderosos» (truthy).
fn main() {
let temperature = 31;
let advice = if temperature > 28 { "stay inside" } else { "go out" };
println!("{advice}");
}
Las dos ramas deben tener el mismo tipo. if x { 1 } else { "one" } es un error de compilación.
Bucles
Rust tiene tres bucles.
fn main() {
// `loop` se ejecuta hasta que haces break. Puede devolver un valor.
let mut n = 1u32;
let first_power_over_1000 = loop {
n *= 2;
if n > 1000 {
break n;
}
};
println!("{first_power_over_1000}");
// `while` se ejecuta mientras se cumple una condición.
let mut countdown = 3;
while countdown > 0 {
println!("{countdown}…");
countdown -= 1;
}
// `for` itera sobre cualquier cosa iterable. Es el bucle que más usarás.
for i in 1..=3 {
println!("lap {i}");
}
for (index, word) in ["alpha", "beta", "gamma"].iter().enumerate() {
println!("{index}: {word}");
}
}
Prefiere for a indexar con un contador. No puede salirse de los límites y suele ser más rápido, porque las comprobaciones de límites desaparecen.
Etiquetas de bucle
Para salir de un bucle exterior desde uno interior, ponle una etiqueta:
fn main() {
'rows: for row in 0..5 {
for col in 0..5 {
if row * col == 6 {
println!("found at ({row}, {col})");
break 'rows;
}
}
}
}
Un primer vistazo a match
match compara un valor con patrones y debe cubrir todas las posibilidades. Conocerás toda su potencia en la lección sobre enums.
fn fizzbuzz(n: u32) -> String {
match (n % 3, n % 5) {
(0, 0) => String::from("FizzBuzz"),
(0, _) => String::from("Fizz"),
(_, 0) => String::from("Buzz"),
_ => n.to_string(),
}
}
fn main() {
for n in 1..=15 {
println!("{}", fizzbuzz(n));
}
}
El patrón _ coincide con cualquier cosa. Borra el último brazo y lee el error: el compilador te dice exactamente qué casos has olvidado.
Ejercicios
- Escribe
fn is_prime(n: u32) -> boole imprime todos los primos menores que 50. - Escribe
fn fib(n: u32) -> u64de forma iterativa, con un buclefory dos variables mutables. - Escribe
fn collatz_steps(mut n: u64) -> u32que cuente los pasos hasta quenllega a 1 (la mitad si es par,3n + 1si es impar).
Solución del 1
fn is_prime(n: u32) -> bool {
if n < 2 {
return false;
}
let mut d = 2;
while d * d <= n {
if n % d == 0 {
return false;
}
d += 1;
}
true
}
fn main() {
for n in 0..50 {
if is_prime(n) {
print!("{n} ");
}
}
println!();
}
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué devuelve esta función?
fn f() -> i32 { 5; }2.¿Qué bucle puede producir un valor con
break valor?3.¿Qué produce
1..=5?