Break y Continue en Rust

break y continue te permiten interrumpir un bucle antes de tiempo, en lugar de ejecutarlo siempre hasta el final. Funcionan igual en los tres tipos de bucle: loop, while y for.

break: salir del bucle por completo

break detiene el bucle de inmediato, y la ejecución salta a lo que venga justo después:

fn main() {
    for i in 1..=10 {
        if i == 5 {
            break;
        }
        println!("{i}");
    }
}

Salida:

1
2
3
4

▶ Pruébalo tú mismo

Aunque el rango llega hasta 10, el bucle se detiene en cuanto i vale 5.

continue: saltar a la siguiente vuelta

continue se salta el resto de la vuelta actual y pasa directamente a la siguiente, en lugar de detener el bucle del todo:

fn main() {
    for i in 1..=10 {
        if i % 2 == 0 {
            continue; // nos saltamos los números pares
        }
        println!("{i}");
    }
}

Salida:

1
3
5
7
9

▶ Pruébalo tú mismo

Todos los números pares se saltan: se ejecuta continue y el bucle pasa directamente al siguiente valor de i sin llegar al println!.

Bucles con etiqueta

Cuando metes un bucle dentro de otro, un break o continue normal solo afecta al bucle más interior. Si necesitas salir de un bucle exterior desde dentro de uno anidado, ponle una etiqueta (label) al bucle exterior, escrita como 'nombre::

fn main() {
    'outer: for x in 1..=3 {
        for y in 1..=3 {
            if x * y > 4 {
                break 'outer;
            }
            println!("{x} x {y} = {}", x * y);
        }
    }
}

Salida:

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
2 x 1 = 2
2 x 2 = 4

▶ Pruébalo tú mismo

Sin la etiqueta, break solo detendría el bucle interior de y, y x seguiría avanzando. break 'outer; detiene los dos a la vez. continue 'outer; funciona igual, por si lo que quieres es saltar a la siguiente vuelta del bucle exterior en lugar de pararlo todo.

Nota

No vas a necesitar bucles con etiqueta muy a menudo: la mayoría del código solo anida bucles en dos niveles, y mucho de él nunca necesita salir del exterior. Conviene reconocerlos cuando los veas, pero no son algo que debas usar por defecto.

La trampa de continue en los bucles while

En un bucle for, el siguiente valor sale del rango automáticamente, así que continue siempre es seguro. Un bucle while es distinto: tú actualizas el contador, normalmente al final del cuerpo. Si continue se salta esa actualización, el contador nunca cambia y el bucle se repite para siempre.

Esta versión intenta saltarse el 3, pero se queda colgada. No la ejecutes:

fn main() {
    let mut i = 0;
    while i < 5 {
        if i == 3 {
            continue; // ❌ vuelve arriba sin cambiar i
        }
        println!("{i}");
        i += 1;
    }
}

Cuando i vale 3, continue vuelve a la condición. i sigue valiendo 3, así que continue se ejecuta otra vez, y otra, para siempre. La solución es actualizar el contador antes de cualquier cosa que pueda hacer continue:

fn main() {
    let mut i = 0;
    while i < 5 {
        i += 1; // actualizamos primero, para que continue no se lo salte
        if i == 3 {
            continue;
        }
        println!("{i}");
    }
}

Salida:

1
2
4
5

▶ Pruébalo tú mismo

Al mover i += 1 arriba, los números se desplazan uno: este bucle imprime del 1 al 5 en lugar del 0 al 4, así que ajusta el inicio o la condición si necesitas el rango de antes. Mejor aún: si solo estás contando, usa un bucle for sobre un rango y el problema no puede ocurrir.

Práctica

1. Sáltate los múltiplos de 3

Imprime los números del 1 al 10, pero sáltate todos los múltiplos de 3. Pista: un número es múltiplo de 3 cuando n % 3 == 0. Usa continue para saltártelo.

Ver solución

fn main() {
    for n in 1..=10 {
        if n % 3 == 0 {
            continue;
        }
        println!("{n}");
    }
}

Salida:

1
2
4
5
7
8
10

▶ Pruébalo tú mismo

2. Encuentra un par que multiplicado dé 24

Usa dos bucles for anidados, x e y, los dos sobre 1..=9. Encuentra el primer par en el que x * y == 24, imprímelo y detén los dos bucles. Pista: ponle una etiqueta al bucle exterior y usa break 'outer;.

Ver solución

fn main() {
    'outer: for x in 1..=9 {
        for y in 1..=9 {
            if x * y == 24 {
                println!("Encontrado: {x} x {y} = 24");
                break 'outer;
            }
        }
    }
    println!("Búsqueda terminada");
}

Salida:

Encontrado: 3 x 8 = 24
Búsqueda terminada

▶ Pruébalo tú mismo

Prueba a cambiar break 'outer; por un simple break;. Ahora solo se detiene el bucle interior, así que la búsqueda continúa y también imprime 4 x 6, 6 x 4 y 8 x 3.

Resumen

• break sale del bucle de inmediato.
• continue se salta el resto de la vuelta actual y pasa a la siguiente.
• Una etiqueta ('outer:) permite que break/continue actúen sobre un bucle exterior desde dentro de uno anidado.
• En un bucle while, actualiza el contador antes de cualquier continue, o el bucle puede quedarse atascado para siempre.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Qué hace continue dentro de un bucle?

Detiene el bucle por completo Se salta el resto de la vuelta actual y pasa a la siguiente Reinicia el bucle desde su primera vuelta

2. ¿Cómo se escribe la etiqueta de un bucle para que break pueda apuntar a él desde un bucle anidado?

#outer @outer 'outer:

3. Un bucle while con continue nunca termina. ¿Cuál es la causa más probable?

continue se salta la línea que actualiza el contador continue no se puede usar en bucles while Al bucle le falta una etiqueta

Puntuación: 0 / 3

Para leer más

• Etiquetas para distinguir entre varios bucles — El libro de Rust (en inglés): la introducción oficial a las etiquetas, con un ejemplo de cuenta atrás anidada.
• Anidamiento y etiquetas — Rust by Example (en inglés): un ejemplo corto y ejecutable de break 'outer y continue 'outer.
• Loop Labels — The Rust Reference (en inglés): las reglas exactas de dónde se pueden usar las etiquetas.
• Expresiones break — The Rust Reference (en inglés): cómo funciona break, incluido break con un valor.
• Expresiones continue — The Rust Reference (en inglés): qué hace continue en cada tipo de bucle.