map, filter, reduce
Crie auxiliares de ordem superior.
map, filter, reduce é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.
As três principais
Mapeamento, filtragem e redução são as principais ferramentas do processamento funcional de listas. Cada uma recebe uma lista e uma função e retorna um resultado sem que você precise escrever o laço manualmente.
Lua não as fornece integradas, mas elas são fáceis de escrever e revelam como funcionam as funções de ordem superior.
Mapeamento: transforme cada item
O mapeamento aplica uma função a cada elemento e reúne os resultados em uma nova lista. A lista original permanece inalterada.
A função que você passa define a transformação, portanto um único map pode duplicar, elevar ao quadrado ou realizar qualquer alteração por item.
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, ", "))O mapeamento mantém o tamanho
Uma operação de mapeamento sempre retorna uma lista com a mesma quantidade de elementos da entrada. Cada item é associado exatamente a um item de saída.
Se você precisa remover itens, essa é a função da filtragem, não do mapeamento.
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)Filtragem: mantenha alguns itens
A filtragem mantém apenas os elementos para os quais um predicado retorna verdadeiro. Um predicado é uma função que retorna um valor booleano.
O resultado é uma nova lista que pode ser menor que a original, mas nunca maior.
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, ", "))A filtragem preserva a ordem
A filtragem percorre a lista em ordem e adiciona ao final cada item mantido, portanto os elementos restantes permanecem na sequência original.
Usar #out + 1 como índice mantém o resultado como uma sequência sem lacunas, que Lua trata como uma sequência 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, ", "))Redução: combine em um só valor
A redução, também chamada de dobra, transforma uma lista em um único valor. Ela mantém um acumulador e o combina com cada elemento usando sua função.
Você fornece um valor inicial e uma função de combinação, e a redução encadeia o acumulador por todos os itens.
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)A redução é flexível
Alterando a função de combinação e o valor inicial, a redução pode somar, multiplicar, encontrar um máximo ou construir uma string.
Aqui, o acumulador começa em 1 e multiplica os valores, produzindo um produto semelhante ao fatorial.
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)Redução até um máximo
A redução não se limita à aritmética. A função de combinação pode comparar valores e manter o maior a cada etapa.
Iniciar o acumulador com o primeiro elemento ou com um número muito pequeno permite que a redução encontre um máximo de forma simples.
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)Encadeando as três
O verdadeiro poder aparece quando você encadeia as três. A filtragem reduz os dados, o mapeamento os transforma e a redução os resume.
Cada etapa é pequena e clara e, juntas, elas substituem um laço manual confuso.
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)Os originais permanecem intactos
O mapeamento e a filtragem sempre criam novas tabelas e nunca modificam a entrada. Isso torna os fluxos de processamento previsíveis: os dados anteriores continuam disponíveis depois de cada etapa.
A redução também deixa a lista intacta, retornando apenas o resultado combinado.
Genérico para qualquer lista
Como a função é um parâmetro, essas ferramentas funcionam com qualquer dado. O mesmo map transforma strings em maiúsculas, ajusta preços ou formata registros.
Escrever o laço uma vez e passar funções diferentes é exatamente o motivo pelo qual as funções de primeira classe são tão úteis.
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, ", "))Verificação rápida
Pense em como essas operações afetam o tamanho da lista.
Recapitulação
O mapeamento transforma cada item e mantém o tamanho, a filtragem mantém os itens que satisfazem um predicado e a redução combina uma lista em um único valor usando um acumulador.
Encadear filtragem, mapeamento e redução cria fluxos de processamento de dados claros sem laços manuais, e as tabelas originais permanecem inalteradas.
Perguntas Frequentes
A aula “map, filter, reduce” é grátis?
Sim — o texto completo de “map, filter, reduce” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.
O que vou aprender em “map, filter, reduce”?
Crie auxiliares de ordem superior. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Lua Academy?
Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “map, filter, reduce”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Lua Academy?
Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Funções como valores
- map, filter, reduce
- Aplicação parcial
- Compondo funções