Lua Academy · Aula

Tabelas como dicionários

Use chaves de texto e chaves mistas para armazenar pares chave-valor.

Tabelas como dicionários é 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.

Chaves de Texto

Tabelas com chaves de texto funcionam como dicionários (mapas hash). Acesse campos usando a notação com ponto t.key (para identificadores válidos) ou a notação com colchetes t["key"] (para qualquer texto). As duas formas são equivalentes; a notação com colchetes permite chaves dinâmicas.

local user = {}
user.name = "Alice"
user["age"] = 30
user.role = "admin"

print(user.name)        -- Alice
print(user["age"])      -- 30

local field = "role"
print(user[field])      -- admin (dynamic key)

Literais de Tabela

Dicionários podem ser inicializados com um literal de tabela usando a sintaxe key = value. Esta é a forma mais comum de criar registros em lua. Você pode misturar entradas no estilo de array e no estilo de dicionário em um único literal.

local config = {
  host = "localhost",
  port = 3306,
  database = "myapp",
  debug = false,
  tags = {"web", "api"},  -- nested array
}

print(config.host)        -- localhost
print(config.port)        -- 3306
print(config.tags[1])     -- web

Contagem com Dicionários

Um caso clássico de uso de dicionários é a contagem de frequências. Itere sobre uma lista, usando cada elemento como chave e incrementando a contagem. Verifique se o valor é nil antes de incrementar — use count[word] or 0 como valor inicial.

local words = {"lua","is","fast","lua","is","lua"}
local freq = {}

for _, w in ipairs(words) do
  freq[w] = (freq[w] or 0) + 1
end

for word, count in pairs(freq) do
  print(word, count)
end
-- lua 3, is 2, fast 1

Agrupamento com Dicionários

Para agrupar dados por uma propriedade, itere sobre a lista e use a chave de agrupamento para adicionar itens a uma lista em um dicionário. Este é o equivalente em lua de GROUP BY do SQL ou do padrão defaultdict do Python.

local people = {
  {name="Alice", dept="eng"},
  {name="Bob",   dept="hr"},
  {name="Carol", dept="eng"},
  {name="Dave",  dept="hr"},
}
local groups = {}

for _, p in ipairs(people) do
  local d = p.dept
  groups[d] = groups[d] or {}
  groups[d][#groups[d]+1] = p.name
end

print(table.concat(groups.eng, ", "))  -- Alice, Carol

Verificando a Existência de Chaves

Teste se uma chave existe comparando seu valor com nil. Tenha cuidado: se o valor armazenado em uma chave for nil, a chave será considerada ausente. Para indicadores de presença, armazene true como valor em vez de nil.

local cache = {result=42, mode="fast"}

if cache.result ~= nil then
  print("cached:", cache.result)  -- 42
end

-- Key not present:
if cache.timeout == nil then
  print("no timeout set")
end

-- Membership set pattern
local allowed = {admin=true, editor=true}
if allowed["admin"] then
  print("access granted")
end

Excluindo Chaves

Defina uma chave da tabela como nil para removê-la. O par chave-valor desaparece, e o coletor de lixo pode recuperar a memória do valor. Não é possível excluir uma variável local dessa forma — apenas entradas de tabelas.

local session = {token="abc123", user="Alice", expires=3600}
print(session.token)   -- abc123

session.token = nil
print(session.token)   -- nil (removed)

-- Count remaining keys
local count = 0
for _ in pairs(session) do count = count + 1 end
print(count)   -- 2

Mesclando Dicionários

Mescle duas tabelas iterando sobre uma delas e copiando suas entradas para a outra. Se ambas tiverem a mesma chave, o valor da segunda tabela prevalecerá. Este é o equivalente em lua de Object.assign do JavaScript.

local defaults = {color="blue", size=12, bold=false}
local overrides = {color="red", italic=true}

local function merge(base, over)
  local result = {}
  for k, v in pairs(base) do result[k] = v end
  for k, v in pairs(over) do result[k] = v end
  return result
end

local opts = merge(defaults, overrides)
print(opts.color, opts.size, opts.italic)  -- red 12 true

Qualquer Tipo de Chave

As chaves de tabelas podem ser qualquer valor não nulo e não NaN: textos, números, booleanos, funções e até outras tabelas. Chaves inteiras e chaves de texto são armazenadas internamente de formas diferentes, mas são acessadas uniformemente com a notação de colchetes.

local t = {}
local function myKey() end

t["string"] = 1
t[42] = 2
t[true] = 3
t[myKey] = 4

print(t["string"])  -- 1
print(t[42])        -- 2
print(t[true])      -- 3
print(t[myKey])     -- 4

Iteração Ordenada

pairs() de lua não garante a ordem de iteração. Para iterar em uma ordem definida, reúna as chaves em um array, ordene-o e então itere sobre ele.

local scores = {Alice=95, Bob=87, Carol=91, Dave=78}

local names = {}
for name in pairs(scores) do
  names[#names+1] = name
end
table.sort(names)

for _, name in ipairs(names) do
  print(name, scores[name])
end
-- Alice 95, Bob 87, Carol 91, Dave 78 (sorted)

Padrão de Valores Padrão

Um padrão útil é uma tabela de "padrões" acessada por meio de uma metatabela __index. Quando uma chave não é encontrada na tabela principal, lua a procura na tabela de padrões. Isso permite uma configuração em camadas sem mesclagem.

local defaults = {timeout=30, retries=3, verbose=false}
local config = {timeout=60}

setmetatable(config, {__index = defaults})

print(config.timeout)  -- 60  (overridden)
print(config.retries)  -- 3   (from defaults)
print(config.verbose)  -- false (from defaults)

Verificação Rápida

Como remover a chave "x" da tabela t em lua?

Recapitulação: Tabelas como Dicionários

Pontos principais:

Notação com ponto e com colchetes: t.key == t["key"]
Qualquer valor não nulo e não NaN pode ser uma chave
Defina como nil para excluir uma chave
Contagem de frequências: t[k] = (t[k] or 0) + 1
Iteração ordenada: reúna as chaves → ordene → itere
Use a metatabela __index para valores padrão

Perguntas Frequentes

A aula “Tabelas como dicionários” é grátis?

Sim — o texto completo de “Tabelas como dicionários” é 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 “Tabelas como dicionários”?

Use chaves de texto e chaves mistas para armazenar pares chave-valor. 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 “Tabelas como dicionários”?

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