0Pricing
Lua Academy · Aula

Laços while e repeat-until

Use while e repeat-until para iterações orientadas por condições.

Laços while e repeat-until é 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.

O laço while

Um laço while repete seu corpo enquanto a condição for verdadeira. A condição é verificada antes de cada iteração. Se a condição for falsa inicialmente, o corpo nunca será executado. Garanta sempre que o laço avance em direção à condição de saída para evitar laços infinitos.

local count = 1

while count <= 5 do
  print(count)
  count = count + 1
end
-- prints 1 through 5

Laço repeat-until

O laço repeat...until é o equivalente, em Lua, ao do-while. O corpo é executado pelo menos uma vez, e a condição é verificada depois de cada iteração. O laço para quando a condição se torna verdadeira (o oposto de while). As variáveis declaradas dentro do corpo ficam visíveis na condição.

local n = 1

repeat
  print(n)
  n = n * 2
until n > 100
-- prints: 1, 2, 4, 8, 16, 32, 64

Laços infinitos com break

Use while true do para laços de eventos ou padrões de repetição, combinado com break para sair quando uma condição for atendida. Esse padrão é comum nos laços principais de jogos e em servidores de rede que funcionam continuamente.

local attempts = 0
local MAX = 3

while true do
  attempts = attempts + 1
  print("Attempt " .. attempts)
  if attempts >= MAX then
    print("Max attempts reached")
    break
  end
end

Contagem regressiva com while

Os laços while também funcionam muito bem para fazer contagens regressivas. O importante é atualizar a variável de modo que a condição de saída seja satisfeita em algum momento. Esquecer de atualizar o contador é uma fonte comum de laços infinitos.

local i = 10

while i > 0 do
  io.write(i .. " ")
  i = i - 1
end
print()   -- newline
-- output: 10 9 8 7 6 5 4 3 2 1

repeat-until para validação de entrada

O padrão repeat-until é ideal para validar entradas: solicite uma vez e verifique depois. Nesse padrão, o corpo sempre é executado pelo menos uma vez, o que corresponde ao fluxo natural de “perguntar e depois validar”.

-- Simulated input validation
local inputs = {-1, 0, 5}  -- pretend user input
local idx = 0
local value

repeat
  idx = idx + 1
  value = inputs[idx]
  print("Got: " .. value)
until value > 0

print("Valid value: " .. value)  -- 5

As variáveis dos laços são locais

As variáveis declaradas com local dentro do corpo de um laço são recriadas a cada iteração. Isso é importante ao capturar variáveis de laço em fechamentos — cada fechamento captura sua própria cópia. As variáveis declaradas fora do laço persistem entre as iterações.

local callbacks = {}

for i = 1, 3 do
  local captured = i        -- local per iteration
  callbacks[i] = function() return captured end
end

print(callbacks[1]())  -- 1
print(callbacks[2]())  -- 2
print(callbacks[3]())  -- 3

Padrão do acumulador

Um caso de uso comum de laços while é acumular um resultado. Soma, produto, concatenação de strings e construção de tabelas seguem o padrão do acumulador: inicialize antes do laço, atualize dentro dele e use o resultado depois.

local numbers = {3, 1, 4, 1, 5, 9, 2, 6}
local sum = 0
local i = 1

while i <= #numbers do
  sum = sum + numbers[i]
  i = i + 1
end

print("Sum:", sum)     -- 31
print("Avg:", sum / #numbers)  -- 3.875

Laços aninhados

Os laços podem ser aninhados. Cada laço mantém seu próprio contador. Use nomes de variáveis descritivos para facilitar a compreensão. A instrução break sai apenas do laço mais interno que a contém — para sair de vários níveis, talvez seja necessário usar uma variável de sinalização ou goto (Lua 5.2+).

local found = false
local target = 6

local i = 1
while i <= 3 and not found do
  local j = 1
  while j <= 3 do
    if i * j == target then
      print(i .. " * " .. j .. " = " .. target)
      found = true
      break
    end
    j = j + 1
  end
  i = i + 1
end

goto para sair de vários níveis

O Lua 5.2+ introduziu goto para saltar para uma posição identificada por um rótulo. Embora seu uso geralmente não seja recomendado, ele é válido para sair de laços aninhados de forma limpa, sem uma variável de sinalização. Os rótulos são definidos com ::name::.

for i = 1, 5 do
  for j = 1, 5 do
  -- goto only valid approach for nested break in Lua
    if i * j > 10 then
      goto done
    end
    io.write(i*j .. " ")
  end
end
::done::
print()
print("Stopped early")

Comparação entre while e repeat

while: use quando talvez sejam necessárias zero iterações — a condição é verificada primeiro. repeat-until: use quando for necessária pelo menos uma iteração — a verificação ocorre depois. Prefira while na maioria dos laços. Use repeat-until em menus, solicitações e laços de repetição nos quais a ação deve ocorrer antes da verificação.

-- while: may execute zero times
local ready = false
while ready do
  print("never prints")
end

-- repeat-until: always executes at least once
local done = false
repeat
  print("runs once even though done=false")
  done = true
until done

Verificação rápida

Quando a condição é verificada em um laço repeat...until?

Recapitulação: while e repeat-until

Pontos principais:

  • while cond do ... end — verifica antes; talvez nem seja executado
  • repeat ... until cond — verifica depois; é executado pelo menos uma vez
  • break sai do laço mais interno
  • goto ::label:: pode sair de laços aninhados (Lua 5.2+)
  • As variáveis locais dos laços são recriadas a cada iteração
  • Use o padrão do acumulador para construir resultados

Perguntas Frequentes

A aula “Laços while e repeat-until” é grátis?

Sim — o texto completo de “Laços while e repeat-until” é 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 “Laços while e repeat-until”?

Use while e repeat-until para iterações orientadas por condições. 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 “Laços while e repeat-until”?

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