Teoría: Condiciones dentro de un bucle

Cuando usamos bucles en programación, su cuerpo es el lugar donde escribimos las acciones que se repiten. Y dentro de ese bloque, también podemos usar herramientas que ya conocemos, como las condiciones (if).

Contar letras en una oración

Imagina que estás programando una app para aprender a leer.
El usuario escribe una oración y tú quieres mostrar cuántas veces aparece una letra.

Por ejemplo:

countChars('Fear cuts deeper than swords.', 'e'); // → 4
countChars('Sansa', 'y'); // → 0

❓ ¿Cómo pensamos la solución?

1. Vamos a recorrer la oración letra por letra.
2. Si encontramos la letra que buscamos, sumamos 1 al contador.
3. Al final, devolvemos cuántas veces apareció.

Así se implementa

const countChars = (text, letter) => {
  let i = 0;
  let count = 0;

  while (i < text.length) {
    if (text[i] === letter) {
      count = count + 1; // o count += 1;
    }
    i = i + 1;
  }

  return count;
};

Paso a paso con 'Fear' y 'e'

i = 0, text[i] = 'F'  // no suma
i = 1, text[i] = 'e'  // ¡coincide! count = 1
i = 2, text[i] = 'a'  // no suma
i = 3, text[i] = 'r'  // no suma

🔁 Y así seguimos hasta revisar toda la frase.

Probar en la consola

console.log(countChars('Winter is coming', 'i')); // → 3
console.log(countChars('Stark', 'a')); // → 1
console.log(countChars('Dragonstone', 'x')); // → 0

Así podrás probar con tus propias frases y letras para ver cómo funciona.

Verificar si un número es divisible

Antes de hablar de números primos, vamos a hacer algo más simple: ver si un número se puede dividir exactamente por otro.

const esDivisible = (a, b) => {
  return a % b === 0;
};

console.log(esDivisible(6, 3)); // true
console.log(esDivisible(7, 3)); // false

❓ ¿Es divisible por otros?

Ahora supongamos que alguien te da un número, y tú quieres probar si se puede dividir por otros más pequeños. Vamos a recorrer varios posibles divisores con un bucle:

const probarDivisores = (numero) => {
  let i = 2;

  while (i < numero) {
    if (numero % i === 0) {
      console.log(`${numero} se puede dividir por ${i}`);
    }
    i++;
  }
};

probarDivisores(12);

Salida:

12 se puede dividir por 2
12 se puede dividir por 3
12 se puede dividir por 4
12 se puede dividir por 6

Y ahora sí: ¿es primo?

Con lo anterior claro, ya podemos probar si un número no se puede dividir por nadie (excepto por 1 y él mismo). Eso significa que es un número primo.

const esPrimo = (numero) => {
  let i = 2;

  while (i < numero) {
    if (numero % i === 0) {
      return false; // encontramos un divisor → no es primo
    }

    i++;
  }

  return numero > 1; // true si no encontramos divisores
};

console.log(esPrimo(7)); // true
console.log(esPrimo(8)); // false
console.log(esPrimo(2)); // true

• Si el número es menor que 2 → no es primo.
• Empezamos a dividir desde 2 hasta la mitad del número.
• Si algún divisor da exacto (sin resto), ya podemos salir: no es primo.
• Si revisamos todo y no hay divisores → sí es primo.

¿Dónde se usa esto?

La función countChars() es útil en buscadores, validaciones de contraseñas, juegos de palabras como Wordle o en análisis de texto. Por otro lado, isPrime() aparece en la lógica de algunos juegos, en algoritmos de seguridad y como ejercicio clásico en entrevistas técnicas.