Estructuras de control WHILE

Hay tareas que consisten en hacer lo mismo varias veces: contar hasta 10, sumar los números de una lista, seguir pidiendo datos hasta que el usuario escriba algo válido. Para eso están los bucles (loops).

while se lee literalmente como “mientras pase esto, repite”. Es el bucle ideal cuando no sabes cuántas veces tendrás que repetir: solo sabes cuándo debes parar.

Objetivos

Al terminar esta lección deberías ser capaz de:

• Escribir un bucle while correctamente.
• Identificar sus tres partes: inicio, condición y actualización.
• Evitar los bucles infinitos.
• Diferenciar while de do...while.
• Usar break y continue para controlar el flujo del bucle.

La forma de un while

while (condicion) {
  // código que se repite
}

Mientras la condición sea true, el bloque se ejecuta una y otra vez. En cuanto sea false, el bucle termina y el programa continúa con la línea siguiente.

contar.js

let contador = 1;

while (contador <= 5) {
  console.log("Vuelta número " + contador);
  contador = contador + 1;
}

console.log("Fin del bucle");

Salida:

Vuelta número 1
Vuelta número 2
Vuelta número 3
Vuelta número 4
Vuelta número 5
Fin del bucle

Las tres piezas que siempre deben estar

Todo while sano tiene tres partes. Si falta alguna, el bucle no funciona o no termina:

Parte	Dónde está	Para qué sirve	En el ejemplo
Inicialización	Antes del bucle	Prepara el valor de partida	let contador = 1
Condición	Entre paréntesis	Decide si se sigue repitiendo	contador <= 5
Actualización	Dentro del bloque	Acerca el bucle a su final	contador = contador + 1

Veamos el recorrido paso a paso:

Vuelta	Valor de contador al entrar	¿contador <= 5?	Acción
1	1	✅ true	Imprime 1, pasa a 2
2	2	✅ true	Imprime 2, pasa a 3
3	3	✅ true	Imprime 3, pasa a 4
4	4	✅ true	Imprime 4, pasa a 5
5	5	✅ true	Imprime 5, pasa a 6
—	6	❌ false	El bucle termina

El error más clásico

Si olvidas la actualización, la condición nunca cambia y el bucle se repite para siempre. Es el bucle infinito: la pestaña se queda colgada y hay que cerrarla o recargar.

bucle-infinito.js

// ❌ NO EJECUTES ESTO: no hay actualización
let i = 1;
while (i <= 5) {
  console.log(i);
  // falta: i = i + 1;
}

Un ejemplo más útil: acumular una suma

suma.js

let numero = 1;
let suma = 0;

while (numero <= 5) {
  suma = suma + numero; // acumulamos
  numero = numero + 1; // avanzamos
}

console.log("La suma del 1 al 5 es " + suma); // 15

Aquí hay dos variables: una que controla el bucle (numero) y otra que guarda el resultado (suma). Es un patrón muy frecuente.

while frente a if

Se parecen en la sintaxis, pero son distintos:

	if	while
Cuántas veces ejecuta el bloque	Una como máximo	Muchas, mientras se cumpla
Cuándo se usa	Tomar una decisión	Repetir una tarea
Necesita actualización	No	Sí, para poder terminar

if-vs-while.js

let x = 1;

if (x <= 3) {
  console.log("if:", x); // se ejecuta una vez
}

while (x <= 3) {
  console.log("while:", x); // se ejecuta tres veces
  x = x + 1;
}

do...while: al menos una vez

A veces necesitas que el bloque se ejecute sí o sí la primera vez, y solo después decidir si se repite. Para eso existe do...while:

do {
  // código
} while (condicion);

do-while.js

let numero = 10;

do {
  console.log("Ejecutando con numero = " + numero);
  numero = numero + 1;
} while (numero <= 5);

// → "Ejecutando con numero = 10" (una vez, aunque la condición era falsa)

La diferencia clave:

	while	do...while
Dónde se comprueba la condición	Antes de entrar	Después de ejecutar
Mínimo de ejecuciones	0	1

Consejo

do...while es típico de menús: “muestra el menú, ejecuta la opción y después pregunta si quieres salir”. El menú debe mostrarse al menos una vez.

break: salir antes de tiempo

break detiene el bucle por completo, aunque la condición siga siendo verdadera.

break.js

let numero = 1;

while (numero <= 10) {
  if (numero === 4) {
    console.log("Encontré el 4, me salgo");
    break;
  }
  console.log(numero);
  numero = numero + 1;
}
// → 1, 2, 3, "Encontré el 4, me salgo"

Es muy útil para búsquedas: en cuanto encuentras lo que buscabas, dejas de recorrer.

continue: saltarse una vuelta

continue no termina el bucle: solo salta el resto de la vuelta actual y pasa a la siguiente.

continue.js

let numero = 0;

while (numero < 5) {
  numero = numero + 1;

  if (numero === 3) {
    continue; // me salto el 3
  }

  console.log(numero);
}
// → 1, 2, 4, 5

Cuidado con continue y la actualización

En el ejemplo, numero = numero + 1 está antes del continue. Si lo pusiéramos después, al saltarse la vuelta no se incrementaría y caeríamos en un bucle infinito. Coloca la actualización donde se ejecute siempre.

¿Cuándo elegir while y cuándo for?

Situación	Bucle recomendado
Sabes cuántas veces vas a repetir (del 1 al 10, de 2 en 2)	for
No sabes cuántas veces: repites hasta que ocurra algo (encontrar un dato, que el usuario acierte, que quede saldo)	while
El bloque debe ejecutarse al menos una vez	do...while

Ejemplo de caso real de while: descontar un saldo hasta que ya no alcance.

saldo.js

let saldo = 10;
const precio = 3;
let compras = 0;

while (saldo >= precio) {
  saldo = saldo - precio;
  compras = compras + 1;
  console.log("Compra " + compras + ", queda " + saldo);
}

console.log("Total de compras: " + compras); // 3
console.log("Saldo final: " + saldo); // 1

Aquí no sabíamos de antemano que serían 3 compras: el bucle lo descubre solo.

Errores frecuentes

Error	Qué provoca	Solución
Falta la actualización	Bucle infinito	Modifica la variable de control dentro del bloque
Condición que nunca se vuelve falsa	Bucle infinito	Comprueba que la condición pueda cambiar
continue antes de actualizar	Bucle infinito	Actualiza antes del continue
Usar = en la condición	Asigna en vez de comparar	Usa <=, ===, etc.
Punto y coma tras el while (...)	El bloque queda fuera del bucle	No pongas ; después de los paréntesis

punto-y-coma-error.js

// ❌ El ; crea un cuerpo vacío: el bloque se ejecuta una sola vez
let i = 1;
while (i <= 3);
{
  console.log(i);
  i = i + 1;
}

Si alguna vez se te cuelga un bucle

En la consola del navegador basta con recargar la pestaña. Si estás en una terminal con Node.js, pulsa Ctrl + C. No pasa nada malo: es un rito de paso de todo programador.

Ejercicio

1. Escribe un while que muestre los números del 10 al 1 en orden descendente.
2. Escribe un while que sume los números pares del 1 al 20 (pista: empieza en 2 y suma 2 en cada vuelta).
3. Crea un bucle con break que se detenga al encontrar el primer número divisible entre 7 a partir de 1.
4. Compara while y do...while con let x = 100 y condición x < 5: ¿cuántas veces se imprime en cada caso?

Resumen

• while repite un bloque mientras la condición sea verdadera; se usa cuando no sabes cuántas vueltas harán falta.
• Todo while necesita inicialización, condición y actualización para terminar.
• Sin actualización aparece el bucle infinito.
• do...while comprueba la condición al final, así que se ejecuta al menos una vez.
• break sale del bucle; continue salta solo la vuelta actual.
• Si ya sabes cuántas iteraciones necesitas, mejor usa for.

Siguiente paso: Estructuras de control FOR.