0Pricing
Lua Academy · Aula

Tabelas como matrizes

Crie e manipule matrizes indexadas a partir de 1 com table.insert e table.remove.

Tabelas como matrizes é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 1 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.

Matrizes Indexadas a Partir de 1

As matrizes de Lua são tabelas com chaves inteiras consecutivas começando em 1. Isso difere da maioria das linguagens, que começa em 0. Essa convenção é universal em Lua — todas as funções da biblioteca padrão presumem indexação baseada em 1. O acesso fora dos limites retorna nil, não um erro.

local colors = {"red", "green", "blue"}
print(colors[1])   -- red
print(colors[2])   -- green
print(colors[3])   -- blue
print(colors[0])   -- nil (no index 0)
print(#colors)     -- 3 (length operator)

table.insert e table.remove

table.insert(t, val) adiciona ao final. table.insert(t, pos, val) insere em uma posição, deslocando os elementos para a direita. table.remove(t, pos) remove o elemento em pos (por padrão, o último), desloca os elementos para a esquerda e retorna o valor removido.

local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print(#stack)          -- 3

table.insert(stack, 2, "inserted")
print(stack[2])        -- inserted

local removed = table.remove(stack, 1)
print(removed)         -- first
print(stack[1])        -- inserted

Pilha com Tabelas

Uma tabela de Lua é uma pilha perfeita. Use table.insert para empilhar e table.remove para desempilhar. Por padrão, as duas operações trabalham no final da tabela, proporcionando tempo amortizado O(1).

local stack = {}

-- Push
table.insert(stack, 10)
table.insert(stack, 20)
table.insert(stack, 30)

-- Pop
print(table.remove(stack))  -- 30
print(table.remove(stack))  -- 20
print(#stack)               -- 1

Fila com Tabelas

Uma fila (FIFO) pode ser implementada com uma tabela, mas table.remove(t, 1) é O(n), pois desloca todos os elementos. Para filas de alto desempenho, use dois ponteiros (índices de início e fim) para evitar deslocamentos.

local head, tail = 1, 0
local queue = {}

local function enqueue(v)
  tail = tail + 1
  queue[tail] = v
end

local function dequeue()
  if head > tail then return nil end
  local v = queue[head]
  queue[head] = nil
  head = head + 1
  return v
end

enqueue("a"); enqueue("b"); enqueue("c")
print(dequeue())  -- a
print(dequeue())  -- b

O Operador de Comprimento #

O operador # retorna a "fronteira" de uma tabela: um índice i tal que t[i] ~= nil e t[i+1] == nil. Para sequências sem espaços vazios, isso corresponde ao comprimento da matriz. Com espaços vazios (nil no meio), # produz resultados indefinidos — use table.pack ou controle o comprimento manualmente.

local t = {10, 20, 30, 40, 50}
print(#t)   -- 5

-- Safe for dense arrays
for i = #t, 1, -1 do
  io.write(t[i] .. " ")
end
print()  -- 50 40 30 20 10

Fatiando Matrizes

Lua não tem uma operação de fatia integrada, mas você pode extrair uma submatriz com table.move (Lua 5.3+) ou com um laço manual. table.move(a1, f, e, t, a2) copia os elementos de a1[f..e] para a2, começando na posição t.

local src = {10,20,30,40,50,60}

-- Manual slice
local function slice(t, from, to)
  local result = {}
  for i = from, to do
    result[#result+1] = t[i]
  end
  return result
end

local sub = slice(src, 2, 4)
print(sub[1], sub[2], sub[3])  -- 20  30  40

Invertendo uma Matriz

Inverta uma tabela no próprio lugar trocando os elementos das duas extremidades em direção ao meio. Este é um algoritmo clássico que funciona em qualquer matriz de Lua sem memória adicional.

local function reverse(t)
  local n = #t
  for i = 1, math.floor(n / 2) do
    t[i], t[n - i + 1] = t[n - i + 1], t[i]
  end
end

local arr = {1, 2, 3, 4, 5}
reverse(arr)
for _, v in ipairs(arr) do
  io.write(v .. " ")
end
print()  -- 5 4 3 2 1

Concatenando Matrizes

Para combinar duas matrizes em uma, percorra a segunda e adicione seus elementos ao final. table.move faz isso com eficiência no Lua 5.3+. O resultado é uma nova tabela contendo todos os elementos das duas matrizes na ordem.

local function concat(a, b)
  local result = {}
  for _, v in ipairs(a) do result[#result+1] = v end
  for _, v in ipairs(b) do result[#result+1] = v end
  return result
end

local merged = concat({1,2,3}, {4,5,6})
for i, v in ipairs(merged) do
  io.write(v .. " ")
end
print()  -- 1 2 3 4 5 6

Achatar Arrays Aninhados

Achate um array aninhado recursivamente: se um elemento for uma tabela, faça a recursão nela; caso contrário, adicione-o ao resultado. Esta é uma aplicação natural da travessia recursiva de tabelas.

local function flatten(t, result)
  result = result or {}
  for _, v in ipairs(t) do
    if type(v) == "table" then
      flatten(v, result)
    else
      result[#result+1] = v
    end
  end
  return result
end

local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print(table.concat(flat, ", "))  -- 1, 2, 3, 4, 5, 6, 7

Array como Conjunto

Você pode implementar um conjunto usando uma tabela em que os valores são chaves e o valor associado é true. A verificação de pertencimento ao conjunto é O(1). Criar um conjunto a partir de um array elimina duplicatas. Converta-o de volta em array iterando com pairs.

local function toSet(arr)
  local set = {}
  for _, v in ipairs(arr) do set[v] = true end
  return set
end

local nums = {3,1,4,1,5,9,2,6,5,3}
local set = toSet(nums)
local unique = {}
for k in pairs(set) do unique[#unique+1] = k end
table.sort(unique)
print(table.concat(unique, " "))  -- 1 2 3 4 5 6 9

Verificação Rápida

O que table.remove(t) faz quando é chamado com apenas um argumento?

Recapitulação: Tabelas como Arrays

Resumo:

  • Arrays de lua são tabelas indexadas a partir de 1
  • table.insert/table.remove para inserir/remover no fim
  • #t fornece o comprimento de sequências sem lacunas
  • Pilha: inserir/remover no fim (O(1))
  • Fila: use ponteiros para início e fim para evitar deslocamentos O(n)
  • Use tabela como conjunto para verificações de pertencimento O(1)

Perguntas Frequentes

A aula “Tabelas como matrizes” é grátis?

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

Crie e manipule matrizes indexadas a partir de 1 com table.insert e table.remove. 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 1 de 4.

Quanto tempo leva a aula “Tabelas como matrizes”?

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