Lua Academy · Aula

Iteradores com estado usando fechamentos

Crie iteradores que mantenham o estado entre chamadas usando fechamentos.

Iteradores com estado usando fechamentos é 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.

Quando os fechamentos ajudam

Quando um iterador precisa manter um estado complexo e em evolução (posição, pilha, histórico), os fechamentos são a ferramenta natural. O estado vive nas variáveis externas.

Padrão de iterador com fechamento

Retorne uma única função; o estado é mantido nas variáveis externas. O for genérico não fornece estado externo — apenas chama a função a cada vez.

local function chars(s)
  local i = 0
  return function()
    i = i + 1
    local c = s:sub(i, i)
    return c ~= "" and c or nil
  end
end
for c in chars("lua") do print(c) end

Iterador de linhas de arquivo

Um iterador clássico de fechamento com estado produz linhas de um identificador de arquivo até EOF.

local function lines(filename)
  local f = io.open(filename, "r")
  return function()
    local line = f:read("*l")
    if not line then f:close() end
    return line
  end
end

Iterador com filtragem

Envolva um iterador existente com um fechamento que ignore os elementos que não correspondam a um predicado.

local function filtered(iter, pred)
  return function()
    local v = iter()
    while v ~= nil and not pred(v) do
      v = iter()
    end
    return v
  end
end

Iterador com mapeamento

Um iterador de mapeamento transforma cada elemento durante a execução, sem criar uma tabela intermediária.

local function mapped(iter, fn)
  return function()
    local v = iter()
    if v ~= nil then return fn(v) end
  end
end

Iterador combinado

Um iterador de combinação obtém dados de dois iteradores simultaneamente e para quando qualquer um deles se esgota.

local function zipped(iter1, iter2)
  return function()
    local a, b = iter1(), iter2()
    if a ~= nil and b ~= nil then return a, b end
  end
end

Iterador encadeado

Um iterador encadeado esgota um iterador antes de passar ao próximo.

local function chained(...)
  local iters = {...}
  local idx = 1
  return function()
    while idx <= #iters do
      local v = iters[idx]()
      if v ~= nil then return v end
      idx = idx + 1
    end
  end
end

Iterador contado

Limite um iterador a no máximo N valores usando um contador em um fechamento.

local function take(n, iter)
  local count = 0
  return function()
    count = count + 1
    if count <= n then return iter() end
  end
end

Iterador de percurso em árvore

Um percurso em profundidade de uma árvore usa uma pilha (uma tabela como valor ascendente) para manter o estado do percurso.

local function dfs(root)
  local stack = {root}
  return function()
    if #stack == 0 then return nil end
    local node = table.remove(stack)
    for _, child in ipairs(node.children or {}) do
      stack[#stack+1] = child
    end
    return node
  end
end

Considerações sobre memória

Iteradores com estado alocam um objeto de fechamento. Para laços internos extremamente restritos, um iterador sem estado pode ser preferível. Em percursos complexos, o fechamento compensa plenamente.

Comparação: com estado e sem estado

Com estado: estado complexo, qualquer ordem de percurso, fácil de escrever.
Sem estado: acesso sequencial simples, nenhuma alocação, rápido.

Pergunta sobre iteradores com estado

Onde um iterador de fechamento com estado armazena seu estado?

Recapitulação: iteradores com estado

Iteradores com estado baseados em fechamentos armazenam estados complexos de percurso em valores ascendentes, permitindo filtros, mapeamentos, árvores e fluxos preguiçosos — todos combináveis e eficientes em memória.

Perguntas Frequentes

A aula “Iteradores com estado usando fechamentos” é grátis?

Sim — o texto completo de “Iteradores com estado usando fechamentos” é 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 “Iteradores com estado usando fechamentos”?

Crie iteradores que mantenham o estado entre chamadas usando fechamentos. 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 “Iteradores com estado usando fechamentos”?

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

Protocolo do for genérico
Iteradores sem estado
Iteradores com estado usando fechamentos
Geradores baseados em corrotinas

← Voltar para Lua Academy