Lua Academy · Lección

Transformación de tablas: map, filter y reduce

Construya helpers funcionales de orden superior para transformar tablas.

Transformación de tablas: map, filter y reduce es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 4 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.

Patrones funcionales en Lua

Lua no incluye map/filter/reduce, pero son muy fáciles de implementar mediante cierres y bucles for genéricos.

map: transformar cada elemento

map aplica una función a cada elemento y devuelve una tabla nueva con los resultados.

local function map(t, fn)
  local result = {}
  for i, v in ipairs(t) do result[i] = fn(v) end
  return result
end
local doubled = map({1,2,3}, function(x) return x * 2 end)
print(table.concat(doubled, ", "))  -- 2, 4, 6

filter: conservar los elementos coincidentes

filter conserva únicamente los elementos para los que el predicado devuelve true.

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 evens = filter({1,2,3,4,5}, function(x) return x % 2 == 0 end)
print(table.concat(evens, ", "))  -- 2, 4

reduce: reducir a un único valor

reduce combina los elementos de izquierda a derecha mediante un acumulador.

local function reduce(t, fn, init)
  local acc = init
  for _, v in ipairs(t) do acc = fn(acc, v) end
  return acc
end
local sum = reduce({1,2,3,4,5}, function(a,b) return a+b end, 0)
print(sum)  -- 15

Encadenar operaciones

Encadene map, filter y reduce para crear canalizaciones de datos expresivas.

local nums = {1,2,3,4,5,6,7,8,9,10}
local result = reduce(
  map(
    filter(nums, function(x) return x % 2 == 0 end),
    function(x) return x * x end
  ),
  function(a,b) return a + b end, 0
)
print(result)  -- 220

forEach: efectos secundarios

forEach itera sin crear una tabla nueva, lo que resulta útil para efectos secundarios como imprimir.

local function forEach(t, fn)
  for i, v in ipairs(t) do fn(v, i) end
end
forEach({"a","b","c"}, function(v, i) print(i, v) end)

flatMap: mapear y después aplanar

flatMap transforma cada elemento en una lista y, después, concatena todas las listas.

local function flatMap(t, fn)
  local result = {}
  for _, v in ipairs(t) do
    for _, item in ipairs(fn(v)) do
      result[#result+1] = item
    end
  end
  return result
end
local expanded = flatMap({1,2,3}, function(x) return {x, x*10} end)

zip: combinar dos tablas

zip empareja los elementos de dos tablas en una tabla de pares.

local function zip(a, b)
  local result = {}
  for i = 1, math.min(#a, #b) do
    result[i] = {a[i], b[i]}
  end
  return result
end
local zipped = zip({1,2,3}, {"a","b","c"})

Trabajar con tablas de diccionario

Para tablas de clave-valor, itere con pairs en lugar de ipairs y recopile los pares de clave-valor.

local function mapValues(t, fn)
  local result = {}
  for k, v in pairs(t) do result[k] = fn(v) end
  return result
end
local doubled = mapValues({x=1,y=2}, function(v) return v*2 end)

Concepto de evaluación diferida

Para conjuntos de datos grandes, considere iteradores perezosos (cierres que producen un elemento cada vez) para evitar crear tablas intermedias grandes.

Nota sobre el rendimiento

Cada map/filter crea una nueva tabla. En bucles ajustados, la mutación en el mismo sitio puede ser más eficiente, aunque sacrifica la inmutabilidad y la claridad.

Pregunta sobre reduce

¿Qué devuelve reduce({1,2,3,4}, function(a,b) return a+b end, 0)?

Repaso: map/filter/reduce

map transforma, filter selecciona y reduce reduce. Estas tres funciones de orden superior forman la base del procesamiento funcional de datos en Lua.

Preguntas frecuentes

¿La lección «Transformación de tablas: map, filter y reduce» es gratis?

Sí — el texto completo de «Transformación de tablas: map, filter y reduce» 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 «Transformación de tablas: map, filter y reduce»?

Construya helpers funcionales de orden superior para transformar tablas. 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 4 de 4.

¿Cuánto tiempo toma la lección «Transformación de tablas: map, filter y reduce»?

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

table.sort con comparadores
table.concat y table.move
Copia profunda y copia superficial
Transformación de tablas: map, filter y reduce

← Volver a Lua Academy