Lua Academy · Lección

map, filter, reduce

Cree helpers de orden superior

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

Los tres grandes

Map, filter y reduce son las herramientas fundamentales para procesar listas de forma funcional. Cada una recibe una lista y una función, y devuelve un resultado sin que tenga que escribir el bucle manualmente.

Lua no las incluye de forma integrada, pero son fáciles de escribir y muestran cómo funcionan las funciones de orden superior.

Map: transformar cada elemento

Map aplica una función a cada elemento y recopila los resultados en una lista nueva. La lista original no se modifica.

La función que proporcione determina la transformación, por lo que un mismo map sirve para duplicar, elevar al cuadrado o realizar cualquier cambio individual.

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

local r = map({1, 2, 3}, function(x) return x * x end)
print(table.concat(r, ", "))

Map conserva la longitud

Map siempre devuelve una lista con el mismo número de elementos que la entrada. Cada elemento se transforma exactamente en un elemento de salida.

Si necesita eliminar elementos, esa es la función de filter, no la de map.

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

local names = {"ada", "lin", "sam"}
local caps = map(names, string.upper)
print(table.concat(caps, " "))
print(#caps)

Filter: conservar algunos elementos

Filter conserva únicamente los elementos para los que un predicado devuelve true. Un predicado es una función que devuelve un valor booleano.

El resultado es una lista nueva que puede ser más corta que la original, pero nunca más larga.

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

local evens = filter({1,2,3,4,5,6}, function(x) return x % 2 == 0 end)
print(table.concat(evens, ", "))

Filter conserva el orden

Filter recorre la lista en orden y añade cada elemento conservado, por lo que los elementos restantes mantienen su secuencia original.

Usar #out + 1 como índice mantiene el resultado como un array sin huecos, que Lua trata como una secuencia válida.

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

local long = filter({"hi", "hello", "yo", "howdy"},
  function(s) return #s > 2 end)
print(table.concat(long, ", "))

Reduce: combinar en un solo valor

Reduce (también llamado fold) condensa una lista en un único valor. Mantiene un acumulador y lo combina con cada elemento mediante la función que proporcione.

Debe proporcionar un valor inicial y una función de combinación; reduce pasa el acumulador por todos los elementos.

local function reduce(t, f, acc)
  for _, v in ipairs(t) do
    acc = f(acc, v)
  end
  return acc
end

local sum = reduce({1,2,3,4}, function(a, x) return a + x end, 0)
print(sum)

Reduce es flexible

Al cambiar la función de combinación y el valor inicial, reduce puede sumar, multiplicar, encontrar un máximo o construir una cadena.

Aquí el acumulador comienza en 1 y se multiplica, produciendo un producto similar al de un factorial.

local function reduce(t, f, acc)
  for _, v in ipairs(t) do acc = f(acc, v) end
  return acc
end

local product = reduce({1,2,3,4,5}, function(a, x) return a * x end, 1)
print(product)

Reduce para obtener un máximo

Reduce no se limita a la aritmética. La función de combinación puede comparar valores y conservar el mayor en cada paso.

Iniciar el acumulador con el primer elemento o con un número muy pequeño permite que reduce encuentre un máximo de forma sencilla.

local function reduce(t, f, acc)
  for _, v in ipairs(t) do acc = f(acc, v) end
  return acc
end

local max = reduce({3, 8, 2, 11, 6},
  function(a, x) if x > a then return x else return a end end, -math.huge)
print(max)

Encadenarlos

La verdadera potencia aparece al encadenar los tres. Filter reduce los datos, map los transforma y reduce los resume.

Cada etapa es un paso pequeño y claro, y juntas sustituyen un bucle manual enrevesado.

local function filter(t, p) local o={} for _,v in ipairs(t) do if p(v) then o[#o+1]=v end end return o end
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function reduce(t, f, a) for _,v in ipairs(t) do a=f(a,v) end return a end

local nums = {1,2,3,4,5,6}
local r = reduce(map(filter(nums, function(x) return x%2==0 end),
  function(x) return x*x end), function(a,x) return a+x end, 0)
print(r)

Los originales permanecen intactos

Map y filter siempre crean tablas nuevas y nunca modifican la entrada. Esto hace que las canalizaciones sean predecibles: los datos anteriores siguen disponibles después de cada etapa.

Reduce tampoco modifica la lista, sino que devuelve únicamente el resultado combinado.

Genéricas para cualquier lista

Como la función es un parámetro, estas herramientas funcionan con cualquier tipo de datos. El mismo map puede convertir cadenas a mayúsculas, escalar precios o dar formato a registros.

Escribir el bucle una sola vez y pasar funciones diferentes es precisamente la razón por la que las funciones de primera clase son tan útiles.

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

local prices = {10, 20, 30}
local withTax = map(prices, function(p) return p * 1.18 end)
print(table.concat(withTax, ", "))

Comprobación rápida

Reflexione sobre cómo afectan estas operaciones a la longitud de una lista.

Recapitulación

Map transforma cada elemento y conserva la longitud, filter conserva los elementos que cumplen un predicado y reduce pliega una lista en un único valor mediante un acumulador.

Encadenar filter, map y reduce crea canalizaciones de datos claras sin bucles manuales, y las tablas originales permanecen sin cambios.

Preguntas frecuentes

¿La lección «map, filter, reduce» es gratis?

Sí — el texto completo de «map, filter, 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 «map, filter, reduce»?

Cree helpers de orden superior 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 2 de 4.

¿Cuánto tiempo toma la lección «map, filter, 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

← Volver a Lua Academy