Lua Academy · Aula

Percorrendo tabelas com pairs e ipairs

Percorra tabelas com segurança usando pairs() e ipairs().

Percorrendo tabelas com pairs e ipairs é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 3 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.

ipairs: Iteração Ordenada de Arrays

ipairs(t) itera sobre a sequência de inteiros que começa no índice 1, produzindo pares (index, value). Ele para no primeiro nil. Esta é a opção segura e previsível para tabelas semelhantes a arrays quando a ordem importa.

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

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

pairs: Todas as Chaves

pairs(t) itera sobre todos os pares chave-valor não nulos da tabela, em ordem não especificada. Internamente, ele usa a função next(). Use pairs para dicionários, tabelas mistas ou quando precisar visitar todas as chaves, independentemente do 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)

Escolhendo entre pairs e ipairs

Use ipairs para arrays sequenciais (ordem garantida, para em nil). Use pairs para dicionários, tabelas mistas ou quando precisar de todas as chaves. Usar pairs em um array funciona, mas não oferece garantia de ordem. Usar ipairs em um dicionário ignora as chaves não inteiras.

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

Contando Elementos

Para sequências, #t fornece a quantidade. Para dicionários, #t não é confiável — itere com pairs e faça a contagem manualmente. Esta é uma distinção importante que evita erros ao trabalhar com tabelas mistas ou com chaves de texto.

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

Modificando Valores durante a Iteração

Você pode atualizar com segurança o valor de uma chave existente enquanto itera com pairs. No entanto, adicionar ou remover chaves durante a iteração tem comportamento indefinido. Reúna as alterações e aplique-as depois do laço.

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

Reunindo Chaves

Uma operação comum é reunir todas as chaves em um array ordenado para obter uma saída determinística. Itere com pairs para coletar as chaves e use table.sort para ordená-las.

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

Iteração de Tabelas Aninhadas

Para tabelas aninhadas (tabela de tabelas), combine dois laços: o laço externo itera sobre o nível superior, e o interno itera sobre cada tabela aninhada. Esse padrão lida com qualquer profundidade usando recursão para aninhamentos realmente arbitrários.

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

Filtragem com ipairs

Crie uma lista filtrada iterando com ipairs e adicionando os elementos que satisfazem um predicado. O resultado é um novo array contendo apenas os elementos correspondentes.

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

Mapeamento com ipairs

Aplique uma transformação a cada elemento: itere e crie um novo array com os valores transformados. Este é o equivalente em lua de map() nas linguagens funcionais.

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 em Iteradores Personalizados

Você pode tornar um objeto personalizado iterável retornando um iterador e um estado a partir de uma função. O padrão reproduz o funcionamento interno de pairs: ele retorna next, t, nil. Sua fábrica de iteradores também retorna uma função e um 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

Verificação Rápida

Qual afirmação sobre pairs() e ipairs() é verdadeira?

Recapitulação: pairs e ipairs

Resumo:

ipairs: ordenado, chaves inteiras começando em 1, para em nil
pairs: todas as chaves, qualquer ordem, nunca para antecipadamente
Use pairs para dicionários; ipairs para arrays
Nunca adicione ou remova chaves durante pairs; atualizar valores existentes é seguro
Reúna e ordene as chaves para obter uma saída determinística

Perguntas Frequentes

A aula “Percorrendo tabelas com pairs e ipairs” é grátis?

Sim — o texto completo de “Percorrendo tabelas com pairs e ipairs” é 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 “Percorrendo tabelas com pairs e ipairs”?

Percorra tabelas com segurança usando pairs() e ipairs(). 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 3 de 4.

Quanto tempo leva a aula “Percorrendo tabelas com pairs e ipairs”?

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

← Voltar para Lua Academy