Lua Academy · Lección

Iteración de tablas con pairs e ipairs

Recorra tablas de forma segura utilizando pairs() e ipairs().

Lección 3 de 412 pasos

Iteración de tablas con pairs e ipairs es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

ipairs: recorrido ordenado de matrices

ipairs(t) recorre la secuencia de enteros que comienza en el índice 1 y devuelve pares (index, value). Se detiene ante el primer nil. Es la opción segura y predecible para tablas similares a matrices cuando el orden es importante.

local fruits = {"apple","banana","cherry"}

for i, fruit in ipairs(fruits) do
  print(i, fruit)
end
-- 1  apple
-- 2  banana
-- 3  cherry

pairs: todas las claves

pairs(t) recorre todos los pares clave-valor no nulos de la tabla, en un orden no especificado. Internamente utiliza la función next(). Use pairs para diccionarios, tablas mixtas o cuando necesite visitar todas las claves independientemente de su tipo.

local info = {name="Lua", version=5.4, embedded=true}

for k, v in pairs(info) do
  print(k, v)
end
-- name  Lua
-- version  5.4
-- embedded  true  (order may vary)

Elegir entre pairs e ipairs

Use ipairs para matrices secuenciales (orden garantizado, se detiene ante nil). Use pairs para diccionarios, tablas mixtas o cuando necesite todas las claves. Usar pairs en una matriz funciona, pero no garantiza ningún orden. Usar ipairs en un diccionario omite las claves que no sean enteros.

local mixed = {10, 20, label="hello", 30}

-- ipairs: only sees 10, 20, 30 in order
for i, v in ipairs(mixed) do
  io.write(v .. " ")
end
print()  -- 10 20 30

-- pairs: sees everything
for k, v in pairs(mixed) do
  print(k, v)
end

Contar elementos

En las secuencias, #t proporciona el recuento. En los diccionarios, #t no es fiable; recorra la tabla con pairs y cuente manualmente. Esta distinción es importante para evitar errores al trabajar con tablas mixtas o con claves de tipo cadena.

local arr = {10, 20, 30}
print("#arr:", #arr)        -- 3 (reliable)

local dict = {a=1, b=2, c=3}
print("#dict:", #dict)      -- 0 (unreliable for dicts!)

local count = 0
for _ in pairs(dict) do count = count + 1 end
print("count:", count)       -- 3

Modificar valores durante el recorrido

Puede actualizar de forma segura el valor de una clave existente mientras recorre la tabla con pairs. Sin embargo, añadir o eliminar claves durante el recorrido produce un comportamiento indefinido. Recopile los cambios y aplíquelos después del bucle.

local prices = {apple=1.0, banana=0.5, cherry=2.0}

-- Safe: update existing values
for k, v in pairs(prices) do
  prices[k] = v * 1.1  -- 10% markup
end

for k, v in pairs(prices) do
  print(k, string.format("%.2f", v))
end

Recopilar claves

Una operación habitual consiste en recopilar todas las claves en una matriz ordenada para obtener una salida determinista. Recorra la tabla con pairs para recopilar las claves y después use table.sort para ordenarlas.

local config = {host="localhost", port=8080, debug=true}
local keys = {}

for k in pairs(config) do
  keys[#keys+1] = k
end
table.sort(keys)

for _, k in ipairs(keys) do
  print(k, "=", config[k])
end
-- debug = true
-- host = localhost
-- port = 8080

Recorrer tablas anidadas

Para tablas anidadas (una tabla de tablas), combine dos bucles: el bucle externo recorre el nivel superior y el interno recorre cada tabla anidada. Este patrón permite gestionar cualquier profundidad mediante recursividad para anidamientos verdaderamente arbitrarios.

local matrix = {
  {1,2,3},
  {4,5,6},
  {7,8,9},
}

for i, row in ipairs(matrix) do
  for j, val in ipairs(row) do
    io.write(string.format("%3d", val))
  end
  print()
end

Filtrar con ipairs

Construya una lista filtrada recorriéndola con ipairs y añadiendo los elementos que cumplan un predicado. El resultado es una matriz nueva que contiene únicamente los elementos coincidentes.

local function filter(t, pred)
  local result = {}
  for _, v in ipairs(t) do
    if pred(v) then result[#result+1] = v end
  end
  return result
end

local nums = {1,2,3,4,5,6,7,8,9,10}
local evens = filter(nums, function(n) return n % 2 == 0 end)
print(table.concat(evens, " "))  -- 2 4 6 8 10

Mapear con ipairs

Aplique una transformación a cada elemento: recórralos y construya una matriz nueva con los valores transformados. Este es el equivalente en Lua de map() en los lenguajes funcionales.

local function map(t, fn)
  local result = {}
  for i, v in ipairs(t) do
    result[i] = fn(v)
  end
  return result
end

local nums = {1, 2, 3, 4, 5}
local doubled = map(nums, function(n) return n * 2 end)
print(table.concat(doubled, " "))  -- 2 4 6 8 10

local words = {"hello","world"}
local upper = map(words, string.upper)
print(table.concat(upper, " "))    -- HELLO WORLD

pairs en iteradores personalizados

Puede hacer que un objeto personalizado sea iterable devolviendo un iterador y un estado desde una función. El patrón refleja el funcionamiento interno de pairs: devuelve next, t, nil. De forma similar, la fábrica de iteradores devuelve una función y un estado opcional.

local function values(t)
  local i = 0
  return function()
    i = i + 1
    return t[i]
  end
end

for v in values({"x","y","z"}) do
  print(v)
end
-- x
-- y
-- z

Comprobación rápida

¿Cuál de las siguientes afirmaciones sobre pairs() e ipairs() es verdadera?

Responde en la lección interactiva

Repaso: pairs e ipairs

Resumen:

ipairs: ordenado, claves enteras desde 1, se detiene ante nil
pairs: todas las claves, en cualquier orden, nunca se detiene antes de tiempo
Use pairs para diccionarios e ipairs para matrices
No añada ni elimine claves durante un recorrido con pairs; actualizar valores existentes es seguro
Recopile y ordene las claves para obtener una salida determinista

Gratis para empezar

Aprende Lua con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 40
Lecciones: 159

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Iteración de tablas con pairs e ipairs» es gratis?

Sí — el texto completo de «Iteración de tablas con pairs e ipairs» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Iteración de tablas con pairs e ipairs»?

Recorra tablas de forma segura utilizando pairs() e ipairs(). Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Iteración de tablas con pairs e ipairs»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Lua Academy