Documentación de HispanoLang

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

📋 Listas (Arrays)

Imagina tu lista de compras del supermercado: tienes varios items escritos en orden. Puedes agregar más items, tachar los que ya compraste, contar cuántos hay, o ver el primer item de la lista. Las listas en programación funcionan igual: colecciones ordenadas de elementos.

¿Qué son las Listas?

Cuando vas al supermercado, haces una lista: 'leche, pan, huevos, manzanas'. En vez de tener 4 variables separadas, tienes UNA lista con todos los items.

variable lista = [elemento1, elemento2, elemento3, ...]
variable compras = ["leche", "pan", "huevos", "manzanas"]
mostrar compras // ["leche", "pan", "huevos", "manzanas"]

variable numeros = [1, 2, 3, 4, 5]
mostrar numeros // [1, 2, 3, 4, 5]

variable mixto = [1, "hola", verdadero, 3.14]
mostrar mixto // [1, "hola", verdadero, 3.14]

variable vacia = []
mostrar "Lista vacía: " + texto(vacia) // Lista vacía: []

variable unoSolo = ["único item"]
mostrar unoSolo // ["único item"]
  • Las listas se crean con corchetes: []
  • Los elementos se separan con comas
  • Pueden contener cualquier tipo de dato
  • Puedes mezclar tipos diferentes
  • Una lista vacía es válida: []

Acceder a Items: Índices

Tu lista tiene posiciones numeradas: el primer item es posición 0, el segundo es posición 1. En programación, SIEMPRE empezamos a contar desde 0.

variable compras = ["leche", "pan", "huevos", "manzanas", "queso"]

mostrar "Item 0 (primero): " + compras[0] // Item 0 (primero): leche
mostrar "Item 1 (segundo): " + compras[1] // Item 1 (segundo): pan
mostrar "Item 2 (tercero): " + compras[2] // Item 2 (tercero): huevos
mostrar "Item 3 (cuarto): " + compras[3] // Item 3 (cuarto): manzanas
mostrar "Item 4 (quinto): " + compras[4] // Item 4 (quinto): queso

variable notas = [85, 90, 78, 92, 88]
mostrar "Primera nota: " + texto(notas[0]) // Primera nota: 85
mostrar "Segunda nota: " + texto(notas[1]) // Segunda nota: 90

variable primerItem = compras[0]
mostrar "Primer item de la lista: " + primerItem // Primer item de la lista: leche
  • Acceso con corchetes: lista[indice]
  • Los índices empiezan en 0, no en 1
  • Primer elemento: lista[0]
  • Segundo elemento: lista[1]
  • Acceder fuera de rango causa error

Modificar Items

Como cuando tachas un item de tu lista y escribes otro, puedes cambiar elementos usando su índice.

variable compras = ["leche", "pan", "huevos"]
mostrar "Lista original: " + texto(compras) // Lista original: ["leche", "pan", "huevos"]

compras[1] = "pan integral"
mostrar "Después de cambiar: " + texto(compras) // Después de cambiar: ["leche", "pan integral", "huevos"]

variable notas = [85, 90, 78]
mostrar "Notas originales: " + texto(notas) // Notas originales: [85, 90, 78]

notas[2] = 80
mostrar "Después de corregir: " + texto(notas) // Después de corregir: [85, 90, 80]

variable tareas = ["Estudiar", "Comprar", "Cocinar"]
tareas[0] = "Estudiar matemáticas"
tareas[2] = "Cocinar pasta"
mostrar "Tareas actualizadas: " + texto(tareas) // Tareas actualizadas: ["Estudiar matemáticas", "Comprar", "Cocinar pasta"]
  • Modificar: lista[indice] = nuevoValor
  • El índice debe existir en la lista
  • La lista mantiene su tamaño
  • Solo cambias el contenido, no agregas ni quitas

Información de la Lista

¿Cuántos items tengo? ¿Cuál es el primero? ¿Cuál es el último?

variable compras = ["leche", "pan", "huevos", "manzanas", "queso"]

mostrar "Cantidad de items: " + texto(compras.longitud()) // Cantidad de items: 5
mostrar "Primer item: " + compras.primero() // Primer item: leche
mostrar "Último item: " + compras.ultimo() // Último item: queso

variable vacia = []
mostrar "Lista vacía tiene: " + texto(vacia.longitud()) + " items" // Lista vacía tiene: 0 items

variable unoSolo = ["único"]
mostrar "Una lista con 1 item:" // Una lista con 1 item:
mostrar "Longitud: " + texto(unoSolo.longitud()) // Longitud: 1
mostrar "Primero: " + unoSolo.primero() // Primero: único
mostrar "Último: " + unoSolo.ultimo() // Último: único
  • .longitud(): Cuántos elementos tiene la lista
  • .primero(): Retorna el primer elemento (índice 0)
  • .ultimo(): Retorna el último elemento
  • Si la lista tiene 1 elemento, primero y último son el mismo

Agregar Items

Como cuando vas agregando items a tu lista de compras conforme recuerdas lo que necesitas.

variable compras = ["leche", "pan"]
mostrar "Inicial: " + texto(compras) // Inicial: ["leche", "pan"]

compras.agregar("huevos")
mostrar "Después de agregar huevos: " + texto(compras) // Después de agregar huevos: ["leche", "pan", "huevos"]

compras.agregar("manzanas")
mostrar "Después de agregar manzanas: " + texto(compras) // Después de agregar manzanas: ["leche", "pan", "huevos", "manzanas"]

mostrar "" // (línea vacía)
mostrar "=== CARRITO DE COMPRAS ===" // === CARRITO DE COMPRAS ===
variable carrito = []
mostrar "Carrito vacío: " + texto(carrito) // Carrito vacío: []

carrito.agregar("Teclado")
carrito.agregar("Mouse")
carrito.agregar("Monitor")
mostrar "Carrito lleno: " + texto(carrito) // Carrito lleno: ["Teclado", "Mouse", "Monitor"]
mostrar "Total de items: " + texto(carrito.longitud()) // Total de items: 3
  • .agregar(elemento): Agrega un elemento al final
  • La lista crece dinámicamente
  • Siempre se agrega al final, no al inicio
  • Útil para carritos, colas, acumulación de datos

Quitar Items

Como cuando tachas el último item de tu lista.

variable compras = ["leche", "pan", "huevos", "manzanas", "queso"]
mostrar "Lista completa: " + texto(compras) // Lista completa: ["leche", "pan", "huevos", "manzanas", "queso"]
mostrar "Longitud: " + texto(compras.longitud()) // Longitud: 5

variable ultimo = compras.remover()
mostrar "Removiste: " + ultimo // Removiste: queso
mostrar "Ahora tienes: " + texto(compras) // Ahora tienes: ["leche", "pan", "huevos", "manzanas"]
mostrar "Longitud: " + texto(compras.longitud()) // Longitud: 4

variable siguiente = compras.remover()
mostrar "Removiste: " + siguiente // Removiste: manzanas
mostrar "Ahora tienes: " + texto(compras) // Ahora tienes: ["leche", "pan", "huevos"]
  • .remover(): Elimina el último elemento y lo retorna
  • La lista se acorta en 1
  • Retorna el elemento eliminado (puedes guardarlo)
  • .agregar() y .remover() trabajan en el mismo extremo (final)

Verificar Existencia

¿Ya escribí 'leche' en mi lista?

variable compras = ["leche", "pan", "huevos", "manzanas"]

mostrar "¿Tengo leche?: " + texto(compras.contiene("leche")) // ¿Tengo leche?: verdadero
mostrar "¿Tengo queso?: " + texto(compras.contiene("queso")) // ¿Tengo queso?: falso
mostrar "¿Tengo pan?: " + texto(compras.contiene("pan")) // ¿Tengo pan?: verdadero

si compras.contiene("huevos") {
  mostrar "Ya tienes huevos en la lista" // Ya tienes huevos en la lista
} sino {
  mostrar "Necesitas agregar huevos"
}

// Validar antes de agregar
variable carrito = ["Mouse", "Teclado"]

variable nuevoItem = "Mouse"
si carrito.contiene(nuevoItem) {
  mostrar nuevoItem + " ya está en el carrito" // Mouse ya está en el carrito
} sino {
  carrito.agregar(nuevoItem)
  mostrar "Agregado: " + nuevoItem
}
  • .contiene(elemento): Verdadero si existe, falso si no
  • Busca el elemento exacto (case-sensitive)
  • Útil para validar antes de agregar
  • Evita duplicados en carrito

Recorrer la Lista

Como cuando pasas por cada línea de tu lista de compras en el super.

variable compras = ["leche", "pan", "huevos", "manzanas"]

mostrar "=== LISTA DE COMPRAS ===" // === LISTA DE COMPRAS ===
compras.recorrer(funcion(item) {
  mostrar "- " + item // - leche, - pan, - huevos, - manzanas (uno por línea)
})

mostrar "" // (línea vacía)
mostrar "=== CON ÍNDICE ===" // === CON ÍNDICE ===
compras.recorrer(funcion(item, indice) {
  mostrar "Item " + texto(indice) + ": " + item // Item 0: leche, Item 1: pan, Item 2: huevos, Item 3: manzanas
})

mostrar "" // (línea vacía)
mostrar "=== CALCULAR TOTAL ===" // === CALCULAR TOTAL ===
variable precios = [100, 250, 150, 300]
variable total = 0

precios.recorrer(funcion(precio) {
  total = total + precio
  mostrar "Agregando $" + texto(precio) + " → Total: $" + texto(total) // Agregando $100 → Total: $100, etc.
})

mostrar "Total final: $" + texto(total) // Total final: $800
  • .recorrer(funcion(elemento) con código)
  • Ejecuta la función una vez por cada elemento
  • Primer parámetro: el elemento actual
  • Segundo parámetro (opcional): índice del elemento

Filtrar y Mapear

Crear nuevas listas basadas en la original.

variable precios = [100, 250, 150, 300, 80, 200]

// Filtrar: solo baratos
variable baratos = precios.filtrar(funcion(precio) {
  retornar precio < 200
})
mostrar "Todos: " + texto(precios) // Todos: [100, 250, 150, 300, 80, 200]
mostrar "Baratos (< $200): " + texto(baratos) // Baratos (< $200): [100, 150, 80]

// Mapear: aplicar IVA
variable conIVA = precios.mapear(funcion(precio) {
  retornar precio * 1.21
})
mostrar "Con IVA: " + texto(conIVA) // Con IVA: [121, 302.5, 181.5, 363, 96.8, 242]

// Números
variable numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

variable pares = numeros.filtrar(funcion(n) {
  retornar n.esPar()
})
mostrar "Pares: " + texto(pares) // Pares: [2, 4, 6, 8, 10]

variable dobles = numeros.mapear(funcion(n) {
  retornar n * 2
})
mostrar "Dobles: " + texto(dobles) // Dobles: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
  • .filtrar(fn): Nueva lista solo con elementos que cumplen
  • .mapear(fn): Nueva lista transformando cada elemento
  • La lista original NO se modifica
  • Muy útiles para procesar datos

Reducir: Combinar Todo en Uno

¿Cuál es el total de mi lista de compras?

variable precios = [100, 250, 150, 300]

variable total = precios.reducir(funcion(acumulado, precio) {
  retornar acumulado + precio
}, 0)
mostrar "Precios: " + texto(precios) // Precios: [100, 250, 150, 300]
mostrar "Total: $" + texto(total) // Total: $800

mostrar "" // (línea vacía)
variable numeros = [1, 2, 3, 4, 5]

variable suma = numeros.reducir(funcion(acc, n) {
  retornar acc + n
}, 0)
mostrar "Suma: " + texto(suma) // Suma: 15

variable producto = numeros.reducir(funcion(acc, n) {
  retornar acc * n
}, 1)
mostrar "Producto: " + texto(producto) // Producto: 120
  • .reducir(fn, inicial): Reduce la lista a un solo valor
  • Combina todos los elementos usando la función
  • Necesita valor inicial (0 para sumas, 1 para productos)
  • Útil para totales, promedios, concatenación

Resumen de métodos de listas:

  • .longitud(): Cantidad de elementos
  • .primero() / .ultimo(): Primer y último elemento
  • .agregar(elem): Agregar al final
  • .remover(): Quitar del final
  • .contiene(elem): Verificar si existe
  • .recorrer(fn): Ejecutar función para cada elemento
  • .filtrar(fn): Nueva lista con elementos que cumplen
  • .mapear(fn): Nueva lista transformando elementos
  • .reducir(fn, init): Combinar en un solo valor