FerrousPath

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 + b es 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

  1. Escribe fn is_prime(n: u32) -> bool e imprime todos los primos menores que 50.
  2. Escribe fn fib(n: u32) -> u64 de forma iterativa, con un bucle for y dos variables mutables.
  3. Escribe fn collatz_steps(mut n: u64) -> u32 que cuente los pasos hasta que n llega a 1 (la mitad si es par, 3n + 1 si 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. 1.¿Qué devuelve esta función? fn f() -> i32 { 5; }

  2. 2.¿Qué bucle puede producir un valor con break valor?

  3. 3.¿Qué produce 1..=5?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?