0Pricing
Lua Academy · Aula

for genérico e break

Use for genérico com pairs/ipairs e controle o fluxo do laço com break.

for genérico e break é 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.

Protocolo do for genérico

O laço for genérico do Lua funciona com uma função iteradora. A sintaxe é for vars in iter_func, state, init do. A cada iteração, o Lua chama iter_func(state, lastVar) e atribui os valores retornados a vars. O laço para quando o primeiro valor retornado é nil.

-- Manual use of next() iterator
local t = {a=1, b=2, c=3}
local key, val = next(t, nil)   -- first entry
while key ~= nil do
  print(key, val)
  key, val = next(t, key)       -- advance
end

pairs() para todas as chaves

pairs(t) retorna um iterador que percorre todos os pares de chave e valor de uma tabela, incluindo chaves de string, chaves inteiras e chaves mistas. A ordem de iteração das chaves não inteiras não é especificada (ordem de hash). Tanto a parte de matriz quanto a parte de hash são incluídas.

local config = {
  host = "localhost",
  port = 8080,
  debug = true,
  [1] = "first",
}

for key, value in pairs(config) do
  print(key, value)
end
-- Prints all 4 entries in any order

ipairs() para chaves de matriz

ipairs(t) percorre as chaves inteiras começando em 1 e para no primeiro valor nil. É seguro, previsível e preserva a ordem. Use ipairs para tabelas semelhantes a matrizes quando a ordem for importante e você quiser parar no primeiro espaço vazio.

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

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

-- stops at first nil
local t = {10, 20, nil, 40}
for i, v in ipairs(t) do
  print(i, v)  -- only 1,10 and 2,20
end

pairs versus ipairs

Saiba quando usar cada um: ipairs é usado para matrizes sequenciais ordenadas; pairs, para dicionários ou tabelas mistas. ipairs para no primeiro espaço vazio com nil; pairs visita todas as chaves que não têm valor nil. Para matrizes puras, ipairs é mais idiomático.

local mixed = {10, 20, key="val", 30}

-- ipairs only sees array part in order
print("ipairs:")
for i, v in ipairs(mixed) do
  print(i, v)  -- 1:10, 2:20, 3:30
end

-- pairs sees everything
print("pairs:")
for k, v in pairs(mixed) do
  print(k, v)  -- 1:10, 2:20, 3:30, key:val
end

Iterador personalizado com fechamento

É possível escrever seu próprio iterador como um fechamento. A função fábrica retorna um fechamento com estado, que avança a posição a cada chamada. Quando não houver mais nada para retornar, ele retorna nil para interromper o for genérico.

local function range(from, to, step)
  step = step or 1
  local i = from - step
  return function()
    i = i + step
    if i <= to then return i end
  end
end

for n in range(1, 10, 2) do
  io.write(n .. " ")
end
print()  -- 1 3 5 7 9

string.gmatch como iterador

string.gmatch(s, pattern) retorna um iterador sobre todas as correspondências do padrão na string s. Ele é usado com frequência para dividir strings, extrair tokens ou encontrar todas as ocorrências de um padrão.

local sentence = "the quick brown fox"

for word in string.gmatch(sentence, "%a+") do
  print(word)
end
-- the
-- quick
-- brown
-- fox

break em for genérico

É possível sair antecipadamente de um laço for genérico usando break. Isso é útil em buscas: percorra os elementos até encontrar uma correspondência e então use break. Depois da saída, a execução continua na instrução após end.

local inventory = {
  {name="sword", damage=50},
  {name="shield", armor=30},
  {name="bow", damage=35},
}

local target = "shield"
for i, item in ipairs(inventory) do
  if item.name == target then
    print("Found at index", i)
    break
  end
end

Modificando tabelas durante a iteração

Nunca insira nem remova chaves de uma tabela enquanto a percorre com pairs() — o comportamento é indefinido (algumas alterações podem ser percebidas, enquanto outras são ignoradas). Se precisar modificar uma tabela, reúna as alterações em uma lista temporária e aplique-as depois do laço.

local t = {a=1, b=2, c=3, d=4}
local toDelete = {}

-- Collect keys to delete
for k, v in pairs(t) do
  if v % 2 == 0 then
    toDelete[#toDelete+1] = k
  end
end

-- Delete after iteration
for _, k in ipairs(toDelete) do
  t[k] = nil
end
-- t = {a=1, c=3}

Padrão de enumeração

Quando precisar tanto do índice quanto do valor, use ipairs, que fornece os dois. Quando precisar apenas dos valores e o índice não for importante, você pode usar _ como nome convencional de variável cujo valor será ignorado.

local colors = {"red", "green", "blue"}

-- With index
for i, color in ipairs(colors) do
  print(i .. ": " .. color)
end

-- Ignore index with _
for _, color in ipairs(colors) do
  print(color)  -- just the values
end

next() diretamente

next(t, key) é a função subjacente de percurso. Ela retorna o próximo par de chave e valor depois de key, ou nil se não houver mais nenhum. next(t, nil) fornece a primeira entrada. Você pode usar next(t) ~= nil para verificar se uma tabela não está vazia — é mais rápido do que fazer a contagem.

local function isEmpty(t)
  return next(t) == nil
end

print(isEmpty({}))       -- true
print(isEmpty({1,2,3}))  -- false
print(isEmpty({a=1}))    -- false

Verificação rápida

Qual iterador para no primeiro espaço vazio com nil em uma tabela?

Recapitulação: for genérico e break

Resumo:

  • pairs(t) — todas as chaves, em qualquer ordem
  • ipairs(t) — chaves inteiras de 1 a n, ordenadas, para em nil
  • Iteradores personalizados: retornam um fechamento que retorna nil para parar
  • break encerra o laço antecipadamente
  • Nunca modifique uma tabela durante o percurso com pairs; reúna as alterações e aplique-as depois
  • next(t) == nil — verificação rápida de tabela vazia

Perguntas Frequentes

A aula “for genérico e break” é grátis?

Sim — o texto completo de “for genérico e break” é 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 “for genérico e break”?

Use for genérico com pairs/ipairs e controle o fluxo do laço com break. 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 “for genérico e break”?

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. Instruções if, elseif e else
  2. Laços while e repeat-until
  3. Laço for numérico
  4. for genérico e break
← Voltar para Lua Academy