Documentación de HispanoLang

Referencia completa de sintaxis, comandos y características del lenguaje

🔄 Bucles

Los bucles son como reproducir una playlist: repites canciones una y otra vez. En programación, los bucles te permiten repetir código sin tener que escribirlo múltiples veces. Imagina tener que escribir 'reproducir canción' 100 veces... ¡imposible! Los bucles lo hacen automáticamente.

¿Qué son los Bucles?

Imagina que tienes una playlist con 50 canciones. En vez de escribir 50 veces 'reproducir canción 1', 'reproducir canción 2', etc., el reproductor usa un bucle: repite la acción de reproducir para cada canción.

// Sin bucles (tedioso y repetitivo)
mostrar "Canción 1" // Canción 1
mostrar "Canción 2" // Canción 2
mostrar "Canción 3" // Canción 3
mostrar "Canción 4" // Canción 4
mostrar "Canción 5" // Canción 5

// Con bucles (limpio y automático)
para (variable cancion = 1; cancion <= 5; cancion++) {
  mostrar "Canción " + cancion // Canción 1, Canción 2, Canción 3, Canción 4, Canción 5
}
  • Sin bucles: tienes que escribir el código repetido muchas veces
  • Con bucles: escribes el código una vez y se repite automáticamente
  • Los bucles son fundamentales: listas, menús, búsquedas, cálculos repetitivos
  • Hay dos tipos principales: 'mientras' (while) y 'para' (for)
  • Los bucles ahorran tiempo, evitan errores y hacen el código más limpio

Bucle mientras: Reproduce Mientras Haya Canciones

El bucle 'mientras' repite código MIENTRAS una condición sea verdadera. Como un reproductor que sigue reproduciendo MIENTRAS queden canciones en la playlist.

mientras condicion ... código ...
variable cancionActual = 1
variable totalCanciones = 5

mientras cancionActual <= totalCanciones {
  mostrar "Reproduciendo canción " + cancionActual // Reproduciendo canción 1, 2, 3, 4, 5
  cancionActual++
}

mostrar "Playlist terminada" // Playlist terminada

variable energia = 100

mientras energia > 0 {
  mostrar "Bailando... Energía: " + energia // Bailando... Energía: 100, 80, 60, 40, 20
  energia = energia - 20
}

mostrar "Sin energía, a descansar" // Sin energía, a descansar
  • mientras evalúa la condición ANTES de cada repetición
  • Si la condición es verdadera → ejecuta el código
  • Si la condición es falsa → sale del bucle
  • IMPORTANTE: Asegúrate que la condición se vuelva falsa en algún momento
  • Si no, tendrás un bucle infinito (nunca termina)

Bucle para: Número Conocido de Repeticiones

El bucle 'para' es perfecto cuando sabes exactamente cuántas veces quieres repetir algo. Como cuando la playlist tiene 10 canciones y quieres reproducirlas todas.

para (inicialización; condición; actualización) ... código ...
// Reproduce 5 canciones
para (variable i = 1; i <= 5; i++) {
  mostrar "Canción " + i // Canción 1, Canción 2, Canción 3, Canción 4, Canción 5
}

mostrar "---" // ---

// Cuenta regresiva para el drop
para (variable segundos = 5; segundos >= 1; segundos--) {
  mostrar segundos + "..." // 5..., 4..., 3..., 2..., 1...
}
mostrar "¡DROP!" // ¡DROP!

mostrar "---" // ---

// Reproduce las primeras 3 canciones
para (variable cancion = 1; cancion <= 3; cancion++) {
  mostrar "Reproduciendo track " + cancion // Reproduciendo track 1, 2, 3
}
  • El bucle 'para' tiene 3 partes separadas por punto y coma:
    1. Inicialización: crear variable contador (empieza en 1)
    1. Condición: mientras contador sea menor o igual a 5
    1. Actualización: incrementar contador después de cada vuelta
  • Más compacto que 'mientras' cuando conoces el número de repeticiones
  • La variable del bucle existe solo dentro del bucle

Bucles Infinitos: El Error Más Común

Un bucle infinito es como una canción en repeat que NUNCA para. El programa se queda atascado para siempre. Esto pasa cuando la condición nunca se vuelve falsa.

// EJEMPLO CORRECTO - El bucle termina
variable contador = 1

mientras contador <= 5 {
  mostrar "Reproduciendo " + contador // Reproduciendo 1, 2, 3, 4, 5
  contador++  // IMPORTANTE: incrementamos el contador
}

mostrar "Playlist terminada" // Playlist terminada

// EJEMPLO DE BUCLE INFINITO (NO HACER):
// variable cancion = 1
// mientras cancion <= 5 {
//     mostrar "Canción " + cancion
//     // Falta cancion++ - el bucle NUNCA termina
// }
  • REGLA: Siempre modifica la variable de la condición dentro del bucle
  • Si la condición nunca cambia, el bucle nunca termina
  • Síntomas de bucle infinito: el programa se cuelga, no responde
  • Solución: asegúrate de que algo dentro del bucle cambie la condición

Casos de Uso: Reproductor de Música

Veamos ejemplos prácticos de bucles en un contexto de reproductor de música.

// Mostrar playlist
variable totalCanciones = 5
mostrar "=== MI PLAYLIST ===" // === MI PLAYLIST ===

para (variable i = 1; i <= totalCanciones; i++) {
  mostrar i + ". Canción " + i // 1. Canción 1, 2. Canción 2, 3. Canción 3, 4. Canción 4, 5. Canción 5
}

mostrar ""

// Reproducir todas
variable cancionActual = 1

mientras cancionActual <= 3 {
  mostrar "Reproduciendo: Canción " + cancionActual // Reproduciendo: Canción 1, 2, 3
  cancionActual++
}

mostrar ""
mostrar "Reproducción completada" // Reproducción completada

// Mostrar progreso
mostrar ""
mostrar "=== PROGRESO ===" // === PROGRESO ===
para (variable progreso = 0; progreso <= 100; progreso += 25) {
  mostrar progreso + "% completado" // 0% completado, 25% completado, 50% completado, 75% completado, 100% completado
}
  • Los bucles son perfectos para recorrer listas de elementos
  • Puedes usar incrementos diferentes para saltar de 25 en 25
  • Combina bucles con condicionales para lógica más compleja
  • El contador puede ir hacia adelante o hacia atrás

Bucles Anidados: Listas Dentro de Listas

A veces necesitas bucles dentro de bucles. Como un reproductor que tiene álbumes, y cada álbum tiene canciones.

// 3 álbumes, cada uno con 2 canciones
para (variable album = 1; album <= 3; album++) {
  mostrar "=== Álbum " + album + " ===" // === Álbum 1 ===, === Álbum 2 ===, === Álbum 3 ===

  para (variable cancion = 1; cancion <= 2; cancion++) {
      mostrar "  Canción " + cancion // Canción 1, Canción 2 (por cada álbum)
  }
}

mostrar ""
mostrar "=== TABLA DE HORARIOS ===" // === TABLA DE HORARIOS ===

// Tabla de horarios: 3 días, 2 clases por día
para (variable dia = 1; dia <= 3; dia++) {
  mostrar "Día " + dia + ":" // Día 1:, Día 2:, Día 3:

  para (variable clase = 1; clase <= 2; clase++) {
      mostrar "  - Clase " + clase // - Clase 1, - Clase 2 (por cada día)
  }
}
  • El bucle externo controla los álbumes/días
  • El bucle interno se ejecuta completo por cada vuelta del externo
  • Usa indentación clara para que sea legible
  • No anides más de 2-3 niveles (se vuelve confuso)
  • Los bucles anidados son útiles para tablas, grillas, matrices

¿Cuándo Usar Cada Tipo de Bucle?

Guía para elegir entre 'mientras' y 'para'.

// PARA: Cuando sabes cuántas veces repetir
mostrar "Ejemplo con PARA:" // Ejemplo con PARA:
para (variable i = 1; i <= 3; i++) {
  mostrar "Repetición " + i // Repetición 1, Repetición 2, Repetición 3
}

mostrar ""

// MIENTRAS: Cuando depende de una condición
mostrar "Ejemplo con MIENTRAS:" // Ejemplo con MIENTRAS:
variable energia = 100

mientras energia > 50 {
  mostrar "Energía: " + energia // Energía: 100, Energía: 80, Energía: 60
  energia -= 20
}

mostrar "Energía baja, descansar" // Energía baja, descansar

Usa 'para' cuando:

  • Sabes exactamente cuántas repeticiones necesitas
  • Recorres una lista de elementos con índice
  • Necesitas un contador (1, 2, 3...)
  • Ejemplo: reproducir 10 canciones, mostrar 5 items

Usa 'mientras' cuando:

  • No sabes cuántas repeticiones necesitas
  • Dependes de una condición externa (input, energía, etc.)
  • Esperas que algo cambie (un valor llegue a 0)
  • Ejemplo: reproducir mientras haya energía, esperar hasta que el usuario responda