Lua Academy · Aula

Transformando tabelas: map, filter, reduce

Crie auxiliares funcionais de ordem superior para transformar tabelas.

Transformando tabelas: map, filter, reduce é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 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.

Padrões Funcionais em Lua

Lua não possui map/filter/reduce integrados, mas eles são simples de implementar usando fechamentos e laços for genéricos.

map: Transformar Cada Elemento

map aplica uma função a cada elemento e retorna uma tabela nova com os 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: Manter Elementos Correspondentes

filter mantém apenas os elementos para os quais o predicado retorna verdadeiro.

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: Reduzir a um Único Valor

reduce combina os elementos da esquerda para a direita usando um 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

Encadeando Operações

Encadeie map, filter e reduce para criar pipelines de dados expressivos.

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: Efeitos Colaterais

forEach percorre os elementos sem criar uma tabela nova — é útil para efeitos colaterais, 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 e Depois Achatar

flatMap mapeia cada elemento para uma lista e depois concatena todas as 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 Duas Tabelas

zip associa elementos de duas tabelas em uma tabela 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"})

Trabalhando com Tabelas de Dicionário

Para tabelas de chave-valor, percorra com pairs em vez de ipairs e reúna os pares de chave e 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)

Conceito de Avaliação Preguiçosa

Para conjuntos de dados grandes, considere iteradores preguiçosos (fechamentos que fornecem um elemento por vez) para evitar a criação de tabelas intermediárias grandes.

Observação sobre Desempenho

Cada map/filter cria uma nova alocação de tabela. Em laços apertados, a mutação no próprio local pode ser mais eficiente, mas sacrifica a imutabilidade e a clareza.

Pergunta sobre reduce

O que reduce({1,2,3,4}, function(a,b) return a+b end, 0) retorna?

Recapitulação: map/filter/reduce

map transforma, filter seleciona e reduce reduz. Essas três funções de ordem superior formam a base do processamento funcional de dados em Lua.

Perguntas Frequentes

A aula “Transformando tabelas: map, filter, reduce” é grátis?

Sim — o texto completo de “Transformando tabelas: 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 “Transformando tabelas: map, filter, reduce”?

Crie auxiliares funcionais de ordem superior para transformar tabelas. 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 4 de 4.

Quanto tempo leva a aula “Transformando tabelas: 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

table.sort com comparadores
table.concat e table.move
Cópia profunda e cópia superficial
Transformando tabelas: map, filter, reduce

← Voltar para Lua Academy