Condiciones y bucles

Tres formas de repetir, y un nombre para cada bucle

En «Variables, funciones y control de flujo» ya usaste if y for de forma informal, sin nombrar por qué if produce un valor ni que existen otras dos formas de repetir. Aquí completamos el vocabulario: loop, while y for cubren casos distintos, y los rangos, las etiquetas y break/continue te dan control fino sobre cuándo parar.

Este vocabulario reaparece en el resto del curso: iteradores, match, y más adelante el operador ? construyen sobre las mismas ideas de expresión y control de flujo que ves aquí.

Verás cuatro estaciones: if como expresión, las tres formas de repetir, rangos y etiquetas, y las dos salidas de un bucle.

CONDICIÓN · n < 0resultado booleano
CAMINO · ambas ramas: i32mismo tipo en las dos ramas
RESULTADO · clamp_lowclamp_low(-5), clamp_low(5)

01 / 04IF · ELSE · MISMO TIPO

Las dos ramas de if deben producir el mismo tipo

if no es solo una bifurcación: es una expresión, y produce un valor. Por eso puedes asignar directamente su resultado con let. Pero hay una condición estricta: las dos ramas deben producir exactamente el mismo tipo.

Las dos ramas de un if-expresión deben producir el mismo tipo.

lib.rsCompila↗

/// `if` is an expression: both branches must produce the same type, and
/// the result can be bound with `let`.
#[must_use]
pub fn clamp_low(n: i32) -> i32 {
    let value = if n < 0 { 0 } else { n };
    value
}

// Playground entry point for this example.
fn main() {
    println!("{} {}", clamp_low(-5), clamp_low(5));
}

Resultado

Si los tipos no coinciden, el compilador no sabe qué tipo darle a la variable.

lib.rsNo compila↗

fn main() {
    let n = 5;
    let label = if n > 0 { "positive" } else { 0 }; // ERROR: branches must match
    println!("{label}");
}

Resultado

El compilador dice (E0308)

`if` and `else` have incompatible types. Una rama produce &str y la otra un entero.

error[E0308]: `if` and `else` have incompatible types
--> src/main.rs:3:48
|
3 |     let label = if n > 0 { "positive" } else { 0 };
|                            ----------          ^ expected `&str`, found integer
|                            |
|                            expected because of this

loop, while y for cubren casos distintos

loop repite indefinidamente hasta un break explícito: úsalo cuando no sepas de antemano cuántas vueltas harán falta. while comprueba una condición antes de cada vuelta. for recorre directamente un rango, una vuelta por elemento, sin que gestiones tú el contador.

Si puedes describir de antemano qué vas a recorrer, for casi siempre es la opción más clara.

lib.rsCompila↗

/// `loop` repeats until an explicit `break`.
#[must_use]
pub fn count_to_three() -> i32 {
    let mut count = 0;
    loop {
        count += 1;
        if count == 3 {
            break;
        }
    }
    count
}

/// `while` checks its condition before every iteration.
#[must_use]
pub fn count_down(mut n: i32) -> i32 {
    while n > 0 {
        n -= 1;
    }
    n
}

/// `for` iterates directly over a range.
#[must_use]
pub fn sum_range(start: i32, end: i32) -> i32 {
    let mut total = 0;
    for n in start..end {
        total += n;
    }
    total
}

// Playground entry point for this example.
fn main() {
    println!("{} {} {}", count_to_three(), count_down(3), sum_range(1, 4));
}

Resultado

Una etiqueta identifica qué bucle debe romperse

Ya usaste rangos como 1..5 (excluye el final) o 1..=5 (lo incluye). Cuando anidas bucles, un break normal solo sale del más interno. Para salir de un bucle exterior directamente, le pones una etiqueta con apóstrofo, como 'outer, y escribes break 'outer desde donde quieras cortar.

lib.rsCompila↗

/// Searches a small grid for the first pair that sums to `target`,
/// breaking out of both loops at once with the `'outer` label.
#[must_use]
pub fn first_pair_summing_to(target: i32) -> Option<(i32, i32)> {
    let mut found = None;

    'outer: for a in 1..5 {
        for b in a..5 {
            if a + b == target {
                found = Some((a, b));
                break 'outer;
            }
        }
    }

    found
}

// Playground entry point for this example.
fn main() {
    println!("{:?}", first_pair_summing_to(7));
}

Resultado

continue salta a la siguiente vuelta; break puede llevar un valor

continue corta la vuelta actual y salta directamente a la siguiente, sin ejecutar el resto del cuerpo del bucle. break, por su parte, no solo termina un loop: puede llevarse un valor consigo, y ese valor se convierte en el resultado de todo el loop.

lib.rsCompila↗

/// `continue` skips straight to the next iteration without running the
/// rest of the loop body.
#[must_use]
pub fn sum_even_up_to(limit: i32) -> i32 {
    let mut total = 0;
    for n in 1..=limit {
        if n % 2 != 0 {
            continue;
        }
        total += n;
    }
    total
}

/// `break` can carry a value out of `loop`; that value becomes the result.
#[must_use]
pub fn first_square_over(threshold: i32) -> i32 {
    let mut n = 0;
    loop {
        n += 1;
        let square = n * n;
        if square > threshold {
            break square;
        }
    }
}

// Playground entry point for this example.
fn main() {
    println!("{} {}", sum_even_up_to(10), first_square_over(50));
}

Resultado

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Objetivo

Completa collatz_steps para que cuente los pasos: si n es par, divide entre 2; si es impar, calcula 3 * n + 1. Repite hasta que n valga 1 y devuelve el número de pasos dados.

Implementa

Sustituye `todo!` por un bucle `while n != 1` con un `if`/`else` para par/impar.

Repite la regla par/impar hasta llegar a 1, sumando una vuelta por cada paso aplicado.

/// Counts the steps the Collatz sequence takes to reach 1 from `start`.
pub fn collatz_steps(start: u64) -> u32 {
    todo!("loop while n != 1: even -> n / 2, odd -> 3 * n + 1, count each step")
}

Comprueba

Ejecuta los casos visibles y usa el diagnóstico para corregir el código.

Pruebas visibles

cuenta los pasos correctos para varias secuencias conocidas

Compilador—

Modifica el código antes de ejecutar las pruebas.

Ayuda

Consulta pistas progresivas o compara con la solución.

Solución comentadaSolución↗

/// Counts the steps the Collatz sequence takes to reach 1 from `start`.
#[must_use]
pub fn collatz_steps(start: u64) -> u32 {
    let mut n = start;
    let mut steps = 0;

    while n != 1 {
        if n % 2 == 0 {
            n /= 2;
        } else {
            n = 3 * n + 1;
        }
        steps += 1;
    }

    steps
}

// Playground entry point for this example.
fn main() {
    println!("{}", collatz_steps(6));
}

Resultado

Resumen

if es una expresión: produce un valor, y sus dos ramas deben tener el mismo tipo.
loop repite hasta un break explícito; while comprueba su condición antes de cada vuelta; for recorre un rango o iterador.
Los rangos ../..= excluyen o incluyen el final; una etiqueta ('outer) identifica qué bucle debe romperse cuando hay varios anidados.
break 'etiqueta sale del bucle exterior directamente, sin banderas auxiliares.
continue salta a la siguiente vuelta sin ejecutar el resto del cuerpo.
break valor termina un loop y ese valor se convierte en el resultado del bucle.

Fuentes

The Rust Programming Languagech03-05 · Klabnik, Nichols, Krycho y la comunidad de Rust
Comprehensive Rustcontrol_flow · Geisler y colaboradores (Google)
Rust by Exampleflow_control

Tres formas de repetir, y un nombre para cada bucle

Cuenta cuántos pasos tarda una secuencia de Collatz en llegar a 1.

Implementa

Contar los pasos de Collatz

Comprueba

Ayuda

Resumen

Fuentes