Bucles while en R: while, repeat y break explicados

El bucle while

Un bucle while en R sigue ejecutando su cuerpo mientras una condición se mantenga TRUE. Donde un bucle for se ejecuta una vez por elemento de algo, while se ejecuta un número desconocido de veces - hasta que una condición cambia:

count <- 1

while (count <= 5) {
  print(count)
  count <- count + 1
}

Tres partes hacen que todo bucle while funcione, y las tres son visibles aquí:

1. La preparación antes del bucle - count <- 1 le da a la condición algo que evaluar.
2. La condición - count <= 5, construida con los operadores de comparación habituales, comprobada antes de cada pasada.
3. La actualización dentro del cuerpo - count <- count + 1 acerca el bucle a su fin.

Borra la parte 3 y la condición será TRUE para siempre: el bucle no termina nunca. Ese es el riesgo que define a while, y el resto de esta página trata en buena medida de gestionarlo.

La condición se comprueba antes de cada pasada

while evalúa su condición primero y luego ejecuta el cuerpo. De ahí se derivan dos consecuencias. Si la condición ya es FALSE al principio, el cuerpo se ejecuta cero veces:

stock <- 0

while (stock > 0) {
  print("selling one item")
  stock <- stock - 1
}

print("loop finished without running")

Y la comprobación ocurre entre pasadas completas, no a mitad del cuerpo - una vez que una pasada empieza, se ejecuta hasta el final aunque la condición pase a FALSE por el camino. Si necesitas salir a mitad del cuerpo, para eso está break (más abajo).

Un ejemplo resuelto: dividir por la mitad hasta bajar de un umbral

El hogar natural de while es el "sigue hasta que": no puedes saber de antemano cuántas pasadas hacen falta, así que for no encaja. ¿Cuántas veces puedes dividir 1000 por la mitad antes de que baje de 1?

value <- 1000
steps <- 0

while (value >= 1) {
  value <- value / 2
  steps <- steps + 1
}

print(steps)
cat("final value:", value, "\n")

Diez divisiones, terminando en unos 0,977. El patrón - una variable de estado que el cuerpo reduce, un contador que hace crecer - cubre una enorme parte de los bucles while reales: métodos numéricos que corren hasta que el error es suficientemente pequeño, simulaciones que corren hasta agotar un recurso, reintentos que continúan hasta que una llamada tiene éxito.

repeat + break: el do-while de R

R no tiene la palabra clave do-while - no hay ningún bucle que evalúe su condición después del cuerpo. Pero tiene repeat, que itera incondicionalmente para siempre, y break, que sale de cualquier bucle de inmediato. Pon la comprobación del break al final del cuerpo de un repeat y habrás construido exactamente un do-while - un bucle cuyo cuerpo se ejecuta al menos una vez garantizado:

n <- 1

repeat {
  n <- n * 2
  if (n > 100) break
}

print(n)

El cuerpo siempre se ejecuta antes de la primera comprobación, así que n se duplica al menos una vez; el bucle sale en 128, la primera duplicación por encima de 100. Usa esta forma cuando "haz la cosa y luego decide si volver a hacerla" sea la descripción honesta - leer entrada hasta que sea válida, extraer muestras hasta que una cumpla. Un repeat sin un break alcanzable es un bucle infinito por construcción, así que escribe primero el break y luego rellena el cuerpo.

break funciona igual en los bucles while y for - es la salida general de "aquí hemos terminado", y se combina de forma natural con sentencias if que evalúan una condición a mitad del cuerpo.

next dentro de un bucle while

next se salta el resto de la pasada actual y vuelve a la comprobación de la condición. Funciona en while igual que en for - con una trampa específica de while: si el paso de actualización viene después del next, saltárselo significa que la variable del bucle nunca avanza y has construido un bucle infinito. Pon la actualización antes del next:

i <- 0

while (i < 10) {
  i <- i + 1          # update FIRST...
  if (i %% 2 != 0) next  # ...then it's safe to skip odd numbers
  print(i)
}

Esto imprime los números pares del 2 al 10. Mueve i <- i + 1 por debajo de la línea del next y el primer valor impar se saltaría la actualización para siempre. En los bucles for este peligro no existe (la variable del bucle avanza automáticamente), lo que es una razón más para preferir for cuando simplemente estás recorriendo una secuencia.

Protegerse de los bucles infinitos

Todo bucle infinito es el mismo error: nada en el cuerpo cambia las variables de las que depende la condición - o las cambia en la dirección equivocada. De forma interactiva puedes interrumpir con Esc o Ctrl+C, pero en un script el proceso simplemente se queda colgado. Dos hábitos lo previenen.

Primero, cuando escribas la condición, pregúntate de inmediato "¿qué línea del cuerpo la mueve hacia FALSE?" y asegúrate de que esa línea se ejecuta en todos los caminos por el cuerpo (ojo con la trampa del next de arriba).

Segundo, para bucles cuya terminación no puedas demostrar con facilidad, añade un límite de iteraciones para que un fallo de lógica produzca un resultado diagnosticable en lugar de una sesión congelada. Aquí protege un bucle al estilo de Collatz - dividir repetidamente los pares por la mitad y convertir la x impar en 3 * x + 1, hasta llegar a 1:

x <- 10
steps <- 0

while (x != 1 && steps < 10000) {
  if (x %% 2 == 0) x <- x / 2 else x <- 3 * x + 1
  steps <- steps + 1
}

cat("reached", x, "after", steps, "steps\n")

Empezando en 10, el bucle llega a 1 en 6 pasos. Si algún valor inicial nunca llegara a 1, la cláusula steps < 10000 terminaría el bucle igualmente, y el estado impreso te diría que algo fue mal - una respuesta incorrecta que puedes ver gana a un programa que nunca responde. El && con cortocircuito es el operador correcto aquí: ambos lados son valores individuales y la protección se lee como una sola frase.

while frente a for: cómo elegir

La regla general va sobre lo que sabes de antemano:

• Sabes sobre qué estás iterando (elementos de un vector, números del 1 al n): usa un bucle for - la variable del bucle se gestiona sola.
• Solo conoces la condición de parada (hasta converger, hasta bajar de un umbral, hasta que sea válido): usa while.
• El cuerpo debe ejecutarse al menos una vez antes de que cualquier comprobación tenga sentido: usa repeat con un break que termine.

Si te ves manteniendo un contador manual en un bucle while solo para recorrer un vector, eso es un bucle for disfrazado - cámbialo.

Lo que te llevas

• while (condition) { ... } comprueba primero y ejecuta después - una condición falsa al principio significa cero pasadas.
• El cuerpo debe mover la condición hacia FALSE; el trío preparación / condición / actualización es toda la disciplina.
• R no tiene palabra clave do-while: repeat { cuerpo; if (done) break } es el modismo, garantizando al menos una pasada.
• break sale de cualquier bucle; con next en un while, actualiza la variable del bucle antes del salto o nunca avanzará.
• Un límite de iteraciones (&& steps < 10000) convierte un posible cuelgue en una respuesta incorrecta visible y depurable.

Lo siguiente: los vectores - la estructura de datos que todos los bucles de esta página han estado recorriendo, y la razón por la que muchos bucles de R pueden desaparecer del todo.