0Pricing
Lua Academy · Aula

Tabelas aninhadas e dados estruturados

Crie estruturas aninhadas e acesse campos profundos.

Tabelas aninhadas e dados estruturados é 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.

Noções Básicas de Tabelas Aninhadas

Tabelas podem conter outras tabelas como valores, criando estruturas com profundidade arbitrária. Acesse campos aninhados encadeando pontos ou colchetes. A ausência de tabelas intermediárias causa erros — sempre garanta que as tabelas pai existam antes de acessar campos profundos.

local company = {
  name = "CoddyKit",
  address = {
    city = "Istanbul",
    country = "Turkey",
    zip = "34000"
  },
  employees = 25
}

print(company.name)            -- CoddyKit
print(company.address.city)    -- Istanbul
print(company["address"]["zip"]) -- 34000

Acesso Profundo Seguro

Acessar um campo de um valor nil causa a falha "attempt to index a nil value". Evite isso usando o curto-circuito de and: t and t.a and t.a.b. Algumas bases de código definem um auxiliar get(t, ...) que percorre com segurança uma cadeia de chaves.

local function get(t, ...)
  local cur = t
  for _, key in ipairs({...}) do
    if type(cur) ~= "table" then return nil end
    cur = cur[key]
  end
  return cur
end

local data = {user = {profile = {age = 30}}}
print(get(data, "user", "profile", "age"))    -- 30
print(get(data, "user", "missing", "field"))  -- nil

Array de Registros

Um padrão comum é um array de tabelas (registros). Cada elemento é uma tabela com campos nomeados. Itere com ipairs e acesse os campos pelo nome. Este é o equivalente em lua de um array de objetos ou de uma lista de estruturas.

local users = {
  {id=1, name="Alice", score=95},
  {id=2, name="Bob",   score=87},
  {id=3, name="Carol", score=91},
}

for _, user in ipairs(users) do
  print(user.id, user.name, user.score)
end

Criando Tabelas Aninhadas Dinamicamente

Crie estruturas aninhadas incrementalmente, criando tabelas internas conforme necessário. Sempre inicialize uma tabela antes de inserir algo nela. Um erro comum é esquecer de criar primeiro a tabela interna e então tentar indexar nil.

local tree = {}
tree.root = {value = 10}
tree.root.left = {value = 5}
tree.root.right = {value = 15}
tree.root.left.left = {value = 2}

print(tree.root.value)            -- 10
print(tree.root.left.value)       -- 5
print(tree.root.left.left.value)  -- 2

Tabela como Configuração Semelhante a JSON

Tabelas de lua são frequentemente usadas para arquivos de configuração, de forma semelhante a JSON ou YAML. O arquivo retorna uma tabela, e a aplicação a carrega com dofile() ou require(). Tabelas aninhadas representam seções de configuração aninhadas.

-- config.lua (returned table)
local config = {
  server = {
    host = "0.0.0.0",
    port = 8080,
    ssl  = false,
  },
  db = {
    host = "localhost",
    name = "appdb",
    pool_size = 10,
  },
  logging = { level = "info", file = "/var/log/app.log" }
}

print(config.server.port)      -- 8080
print(config.db.pool_size)    -- 10

Grafo como Lista de Adjacência

Represente um grafo como uma tabela de tabelas: cada chave é um nó, e seu valor é uma lista de vizinhos. Essa representação por lista de adjacência é eficiente em termos de memória para grafos esparsos e fácil de usar em lua.

local graph = {
  A = {"B", "C"},
  B = {"A", "D"},
  C = {"A", "D"},
  D = {"B", "C"},
}

-- BFS from A
local visited = {A=true}
local queue = {"A"}
while #queue > 0 do
  local node = table.remove(queue, 1)
  io.write(node .. " ")
  for _, neighbor in ipairs(graph[node]) do
    if not visited[neighbor] then
      visited[neighbor] = true
      queue[#queue+1] = neighbor
    end
  end
end
print()  -- A B C D

Modificando Campos Aninhados

Modifique campos aninhados acessando a tabela pai e atribuindo um valor à chave. Como tabelas são passadas por referência, qualquer função que receba uma tabela pode modificar seu conteúdo diretamente — o chamador vê as alterações.

local player = {name="Hero", stats={hp=100, mp=50, atk=20}}

local function takeDamage(p, dmg)
  p.stats.hp = math.max(0, p.stats.hp - dmg)
end

takeDamage(player, 35)
print(player.stats.hp)   -- 65

player.stats.atk = player.stats.atk + 5
print(player.stats.atk)  -- 25

Serializando Tabelas Aninhadas

Converter uma tabela aninhada em texto é útil para depuração ou registro. Um serializador recursivo simples lida com qualquer profundidade, embora não lide com ciclos (referências circulares).

local function serialize(val, indent)
  indent = indent or 0
  local pad = string.rep("  ", indent)
  if type(val) ~= "table" then
    return tostring(val)
  end
  local parts = {"{"}
  for k, v in pairs(val) do
    parts[#parts+1] = pad.."  "..tostring(k).."="..serialize(v,indent+1)
  end
  parts[#parts+1] = pad.."}"
  return table.concat(parts, "\n")
end
local data = {x=1, nested={y=2, z=3}}
print(serialize(data))

Matrizes Esparsas

Armazenar ingenuamente uma matriz 2D desperdiça memória para entradas grandes e esparsas. Armazene apenas as entradas não nulas em uma tabela aninhada: matrix[row][col] = value. Isso pode representar matrizes enormes com eficiência quando a maioria dos valores é zero.

local function newMatrix()
  return setmetatable({}, {__index=function(t,k)
    local row = {}
    rawset(t, k, row)
    return row
  end})
end

local m = newMatrix()
m[1][1] = 5
m[3][7] = 12
m[100][200] = 99

print(m[1][1])    -- 5
print(m[3][7])    -- 12
print(m[2][5])    -- nil (sparse: no value)

Verificação de Igualdade Profunda

Tabelas são comparadas por referência com ==, não por valor. Para comparar estruturalmente tabelas aninhadas, escreva uma função recursiva de igualdade que compare cada par chave-valor e faça a recursão nas tabelas aninhadas.

local function deepEqual(a, b)
  if type(a) ~= type(b) then return false end
  if type(a) ~= "table" then return a == b end
  for k, v in pairs(a) do
    if not deepEqual(v, b[k]) then return false end
  end
  for k in pairs(b) do
    if a[k] == nil then return false end
  end
  return true
end
print(deepEqual({1,{2,3}},{1,{2,3}}))  -- true
print(deepEqual({1,{2,3}},{1,{2,4}}))  -- false

Verificação Rápida

O que acontece quando você acessa t.a.b e t.a é nil?

Recapitulação: Tabelas Aninhadas

Resumo:

  • Tabelas podem ser aninhadas arbitrariamente: t.a.b.c
  • Proteja o acesso profundo: t and t.a and t.a.b
  • Tabelas são tipos por referência — funções as modificam diretamente
  • Array de registros: {{name=...},{name=...}}
  • Matriz esparsa: tabelas aninhadas para eficiência de memória
  • A igualdade profunda exige comparação recursiva

Perguntas Frequentes

A aula “Tabelas aninhadas e dados estruturados” é grátis?

Sim — o texto completo de “Tabelas aninhadas e dados estruturados” é 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 aninhadas e dados estruturados”?

Crie estruturas aninhadas e acesse campos profundos. 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 “Tabelas aninhadas e dados estruturados”?

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

  1. Tabelas como matrizes
  2. Tabelas como dicionários
  3. Percorrendo tabelas com pairs e ipairs
  4. Tabelas aninhadas e dados estruturados
← Voltar para Lua Academy