Explora las estructuras de bucle en JavaScript

JavaScriptBeginner
Practicar Ahora

Introducción

En este laboratorio, los estudiantes profundizarán en las estructuras de bucles de JavaScript, explorando diversas técnicas de iteración que son fundamentales para la lógica de programación. El laboratorio aborda los tipos esenciales de bucles, incluyendo bucles while, do-while, for y for-in, brindando experiencia práctica con cada estructura a través de ejemplos de codificación prácticos y aprendizaje incremental.

Los participantes comenzarán por entender la sintaxis básica de los bucles while, aprendiendo cómo crear iteraciones controladas y realizar tareas como contar y buscar condicionalmente. A medida que avancen, practicarán implementar diferentes estructuras de bucles, comparando sus características y casos de uso únicos, lo que les ayudará a desarrollar una comprensión integral de cómo los bucles se pueden utilizar para manipular datos, iterar a través de arrays y crear soluciones de programación dinámica en JavaScript.

Comprende la sintaxis y el uso básico del bucle while

En este paso, aprenderás sobre la sintaxis y el uso básico de los bucles while en JavaScript. Los bucles while son estructuras de control fundamentales que te permiten repetir un bloque de código mientras una condición especificada sea verdadera.

Comencemos creando un nuevo archivo de JavaScript para explorar los bucles while. Abra el WebIDE y cree un archivo llamado whileLoop.js en el directorio ~/project.

// Crea un bucle while simple para contar del 1 al 5
let count = 1;

while (count <= 5) {
  console.log(`Contador actual: ${count}`);
  count++;
}

Ahora, ejecute el archivo de JavaScript usando Node.js para ver la salida:

node ~/project/whileLoop.js

Salida de ejemplo:

Contador actual: 1
Contador actual: 2
Contador actual: 3
Contador actual: 4
Contador actual: 5

Analicemos la sintaxis del bucle while:

  • let count = 1; inicializa una variable contador antes del bucle
  • while (count <= 5) define la condición que debe ser verdadera para continuar con el bucle
  • console.log() imprime el valor actual de count
  • count++ incrementa el contador en cada iteración

Ahora, creemos un ejemplo más práctico que demuestre un bucle while con una condición más compleja:

// Crea un bucle while para encontrar el primer número divisible por 3 y 5
let number = 1;

while (!(number % 3 === 0 && number % 5 === 0)) {
  number++;
}

console.log(`Primer número divisible por 3 y 5: ${number}`);

Ejecute el archivo nuevamente:

node ~/project/whileLoop.js

Salida de ejemplo:

Primer número divisible por 3 y 5: 15

Este ejemplo muestra cómo los bucles while se pueden utilizar para buscar condiciones específicas o realizar tareas iterativas.

Practica el bucle Do-While con iteración incremental

En este paso, aprenderás sobre los bucles do-while en JavaScript, que son similares a los bucles while pero con una diferencia clave: el bloque de código se ejecuta al menos una vez antes de comprobar la condición.

Crea un nuevo archivo llamado doWhileLoop.js en el directorio ~/project usando el WebIDE:

// Demuestra un bucle do-while con simulación de entrada del usuario
let attempts = 0;
let secretNumber = 7;
let guess;

do {
  // Simula una suposición aleatoria entre 1 y 10
  guess = Math.floor(Math.random() * 10) + 1;
  attempts++;

  console.log(`Intento ${attempts}: Suplicado ${guess}`);

  if (guess === secretNumber) {
    console.log(
      `¡Felicitaciones! Adivinaste el número en ${attempts} intentos.`
    );
  }
} while (guess !== secretNumber);

Ejecuta el archivo de JavaScript para ver cómo funciona el bucle do-while:

node ~/project/doWhileLoop.js

Salida de ejemplo:

Intento 1: Suplicado 3
Intento 2: Suplicado 9
Intento 3: Suplicado 7
¡Felicitaciones! Adivinaste el número en 3 intentos.

Características clave de los bucles do-while:

  • El bloque de código se ejecuta al menos una vez antes de comprobar la condición
  • La condición se comprueba al final de cada iteración
  • Útil cuando quieres asegurar que el código se ejecute al menos una vez

Vamos a crear otro ejemplo para ilustrar aún más el bucle do-while:

// Demuestra la iteración incremental con el bucle do-while
let total = 0;
let i = 1;

do {
  total += i;
  console.log(`Total actual: ${total}, Número actual: ${i}`);
  i++;
} while (total < 10);

console.log(`Total final: ${total}`);

Ejecuta el archivo nuevamente:

node ~/project/doWhileLoop.js

Salida de ejemplo:

Total actual: 1, Número actual: 1
Total actual: 3, Número actual: 2
Total actual: 6, Número actual: 3
Total actual: 10, Número actual: 4
Total final: 10

Este ejemplo muestra cómo los bucles do-while se pueden utilizar para la iteración incremental, asegurando que el bloque de código se ejecute al menos una vez antes de comprobar la condición de terminación.

Implementa el bucle For para iteraciones controladas

En este paso, aprenderás sobre los bucles for en JavaScript, que proporcionan una forma concisa de realizar iteraciones controladas con un inicio, un final y un mecanismo de incremento/decremento claros.

Crea un nuevo archivo llamado forLoop.js en el directorio ~/project usando el WebIDE:

// Bucle for básico para imprimir números del 1 al 5
console.log("Bucle de conteo básico:");
for (let i = 1; i <= 5; i++) {
  console.log(`Número actual: ${i}`);
}

// Bucle for para calcular el factorial de un número
console.log("\nCálculo de factorial:");
let number = 5;
let factorial = 1;

for (let j = 1; j <= number; j++) {
  factorial *= j;
}

console.log(`El factorial de ${number} es: ${factorial}`);

// Bucle for para iterar a través de un array
console.log("\nIteración de array:");
let fruits = ["apple", "banana", "cherry", "date"];

for (let k = 0; k < fruits.length; k++) {
  console.log(`Fruta en el índice ${k}: ${fruits[k]}`);
}

Ejecuta el archivo de JavaScript para ver los diferentes ejemplos de bucle for:

node ~/project/forLoop.js

Salida de ejemplo:

Bucle de conteo básico:
Número actual: 1
Número actual: 2
Número actual: 3
Número actual: 4
Número actual: 5

Cálculo de factorial:
El factorial de 5 es: 120

Iteración de array:
Fruta en el índice 0: apple
Fruta en el índice 1: banana
Fruta en el índice 2: cherry
Fruta en el índice 3: date

Analicemos la sintaxis del bucle for:

  • for (inicialización; condición; incremento/decremento) es la estructura estándar
  • let i = 1 inicializa el contador del bucle
  • i <= 5 define la condición de continuación
  • i++ incrementa el contador después de cada iteración

Crea otro ejemplo que demuestre un uso más complejo del bucle for:

// Bucle for anidado para crear una tabla de multiplicar
console.log("Tabla de multiplicar:");
for (let row = 1; row <= 5; row++) {
  let rowOutput = "";
  for (let col = 1; col <= 5; col++) {
    rowOutput += `${row * col}\t`;
  }
  console.log(rowOutput);
}

Ejecuta el archivo nuevamente:

node ~/project/forLoop.js

Salida de ejemplo:

Tabla de multiplicar:
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
5 10 15 20 25

Este ejemplo muestra cómo los bucles for anidados se pueden utilizar para crear patrones de iteración más complejos.

Utiliza el bucle For-In para iterar a través de los elementos de un array

En este paso, aprenderás sobre el bucle for-in en JavaScript, que proporciona una forma fácil de iterar a través de las propiedades de un objeto o los elementos de un array.

Crea un nuevo archivo llamado forInLoop.js en el directorio ~/project usando el WebIDE:

// Iterando a través de un array usando el bucle for-in
let fruits = ["apple", "banana", "cherry", "date"];

console.log("Iterando a través de los índices del array:");
for (let index in fruits) {
  console.log(`Índice: ${index}, Fruta: ${fruits[index]}`);
}

// Iterando a través de un objeto usando el bucle for-in
let student = {
  name: "John Doe",
  age: 22,
  major: "Computer Science",
  gpa: 3.8
};

console.log("\nIterando a través de las propiedades del objeto:");
for (let property in student) {
  console.log(`${property}: ${student[property]}`);
}

// Ejemplo práctico: Calculando el precio total de los artículos
let shoppingCart = [
  { name: "Laptop", price: 1000 },
  { name: "Headphones", price: 100 },
  { name: "Mouse", price: 50 }
];

console.log("\nCalculando el precio total:");
let totalPrice = 0;
for (let index in shoppingCart) {
  totalPrice += shoppingCart[index].price;
}
console.log(`Precio total: $${totalPrice}`);

Ejecuta el archivo de JavaScript para ver el bucle for-in en acción:

node ~/project/forInLoop.js

Salida de ejemplo:

Iterando a través de los índices del array:
Índice: 0, Fruta: apple
Índice: 1, Fruta: banana
Índice: 2, Fruta: cherry
Índice: 3, Fruta: date

Iterando a través de las propiedades del objeto:
name: John Doe
age: 22
major: Computer Science
gpa: 3.8

Calculando el precio total:
Precio total: $1150

Puntos claves sobre los bucles for-in:

  • Funciona con arrays y objetos
  • Itera a través de los índices (para arrays) o propiedades (para objetos)
  • Proporciona una forma simple de acceder a los elementos sin usar bucles basados en índices tradicionales
  • Tenga cuidado al usar con arrays, ya que itera a través de todas las propiedades enumerables

Vamos a explorar otro ejemplo para demostrar su flexibilidad:

// Usando el bucle for-in para filtrar y transformar datos
let grades = {
  math: 85,
  science: 92,
  english: 78,
  history: 88
};

console.log("Filtrando calificaciones por encima de 80:");
for (let subject in grades) {
  if (grades[subject] > 80) {
    console.log(`${subject}: ${grades[subject]}`);
  }
}

Ejecuta el archivo nuevamente:

node ~/project/forInLoop.js

Salida de ejemplo:

Filtrando calificaciones por encima de 80:
math: 85
science: 92
history: 88

Compara y contrasta diferentes estructuras de bucles

En este paso, explorarás las diferencias entre las diversas estructuras de bucle en JavaScript y aprenderás cuándo usar efectivamente cada tipo de bucle.

Crea un nuevo archivo llamado loopComparison.js en el directorio ~/project usando el WebIDE:

// Demostrando diferentes estructuras de bucle para la misma tarea

// 1. Bucle While: Mejor para un número desconocido de iteraciones
console.log("Ejemplo de Bucle While:");
let whileCounter = 1;
while (whileCounter <= 5) {
  console.log(`Bucle While: ${whileCounter}`);
  whileCounter++;
}

// 2. Bucle Do-While: Asegura al menos una ejecución
console.log("\nEjemplo de Bucle Do-While:");
let doWhileCounter = 1;
do {
  console.log(`Bucle Do-While: ${doWhileCounter}`);
  doWhileCounter++;
} while (doWhileCounter <= 5);

// 3. Bucle For: Mejor para un número conocido de iteraciones
console.log("\nEjemplo de Bucle For:");
for (let forCounter = 1; forCounter <= 5; forCounter++) {
  console.log(`Bucle For: ${forCounter}`);
}

// 4. Bucle For-In: Iterando a través de las propiedades de un objeto
console.log("\nEjemplo de Bucle For-In:");
let student = {
  name: "John Doe",
  age: 22,
  major: "Computer Science"
};

for (let property in student) {
  console.log(`${property}: ${student[property]}`);
}

// 5. Comparando el Rendimiento de los Bucles
console.log("\nComparación de Rendimiento de los Bucles:");
const iterations = 1000000;

console.time("Bucle While");
let a = 0;
while (a < iterations) {
  a++;
}
console.timeEnd("Bucle While");

console.time("Bucle For");
for (let b = 0; b < iterations; b++) {}
console.timeEnd("Bucle For");

Ejecuta el archivo de JavaScript para ver la comparación:

node ~/project/loopComparison.js

Salida de ejemplo:

Ejemplo de Bucle While:
Bucle While: 1
Bucle While: 2
Bucle While: 3
Bucle While: 4
Bucle While: 5

Ejemplo de Bucle Do-While:
Bucle Do-While: 1
Bucle Do-While: 2
Bucle Do-While: 3
Bucle Do-While: 4
Bucle Do-While: 5

Ejemplo de Bucle For:
Bucle For: 1
Bucle For: 2
Bucle For: 3
Bucle For: 4
Bucle For: 5

Ejemplo de Bucle For-In:
name: John Doe
age: 22
major: Computer Science

Comparación de Rendimiento de los Bucles:
Bucle While: 2.345ms
Bucle For: 1.876ms

Diferencias Clave:

  1. Bucle While:

    • Utilizar cuando el número de iteraciones es desconocido
    • La condición se comprueba antes de cada iteración
    • Puede no ejecutarse si la condición es falsa inicialmente
  2. Bucle Do-While:

    • Garantiza al menos una ejecución
    • La condición se comprueba después de cada iteración
    • Útil cuando quieres ejecutar el código al menos una vez
  3. Bucle For:

    • Mejor para un número conocido de iteraciones
    • Sintaxis compacta con inicialización, condición e incremento
    • Muy comúnmente utilizado para la iteración de arrays y conteo
  4. Bucle For-In:

    • Específicamente para iterar a través de las propiedades de un objeto
    • Funciona con objetos y arrays
    • Proporciona nombres de índice o propiedades

Vamos a crear un último ejemplo para demostrar la selección del bucle adecuado:

// Elegir el bucle adecuado para diferentes escenarios
let numbers = [10, 20, 30, 40, 50];

// Bucle While para búsqueda condicional
console.log("\nElegir el Bucle Adecuado:");
let searchValue = 30;
let index = 0;
while (index < numbers.length && numbers[index] !== searchValue) {
  index++;
}
console.log(`Encontrado ${searchValue} en el índice: ${index}`);

// Bucle For para iteración simple
console.log("Números al Cuadrado:");
for (let i = 0; i < numbers.length; i++) {
  console.log(`${numbers[i]} al cuadrado: ${numbers[i] * numbers[i]}`);
}

Ejecuta el archivo nuevamente:

node ~/project/loopComparison.js

Salida de ejemplo:

Elegir el Bucle Adecuado:
Encontrado 30 en el índice: 2
Números al Cuadrado:
10 al cuadrado: 100
20 al cuadrado: 400
30 al cuadrado: 900
40 al cuadrado: 1600
50 al cuadrado: 2500

Resumen

En este laboratorio, los participantes exploraron diversas estructuras de bucle en JavaScript, centrándose en la comprensión e implementación de diferentes tipos de bucles. El laboratorio comenzó con una exhaustiva revisión de los bucles while, demostrando su sintaxis básica y aplicaciones prácticas a través de ejemplos que cuentan iteraciones y buscan condiciones numéricas específicas. Los participantes aprendieron cómo inicializar variables de bucle, definir condiciones de bucle y usar operadores de incremento para controlar la ejecución del bucle.

El laboratorio avanzó para cubrir tipos adicionales de bucles, incluyendo bucles do-while, for y for-in, brindando experiencia práctica con cada estructura. Al comparar y contrastar estos mecanismos de bucle, los aprendices obtuvieron conocimientos sobre la selección de estructuras de bucle adecuadas para diferentes escenarios de programación, mejorando sus habilidades de programación en JavaScript y su comprensión de los mecanismos de flujo de control.