Lua Academy · Aula

Laço for numérico

Percorra intervalos numéricos com a sintaxe for i=start,limit,step.

Laço for numérico é 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.

Sintaxe do for numérico

O laço for numérico do Lua tem o formato for var = start, limit, step do. O step assume o valor 1 se for omitido. A variável do laço é local ao corpo do laço e não pode ser modificada dentro dele. O limite e o passo são avaliados uma vez antes do início do laço.

-- Count 1 to 5
for i = 1, 5 do
  io.write(i .. " ")
end
print()   -- 1 2 3 4 5

-- Count with step 2
for i = 1, 10, 2 do
  io.write(i .. " ")
end
print()   -- 1 3 5 7 9

Contagem regressiva com passo negativo

Use um passo negativo para fazer uma contagem regressiva. O laço continua enquanto var >= limit (quando o passo é negativo). Se o início já for menor que o limite com um passo negativo, o corpo do laço nunca será executado.

for i = 10, 1, -1 do
  io.write(i .. " ")
end
print()
-- 10 9 8 7 6 5 4 3 2 1

-- Step -2
for i = 10, 0, -2 do
  io.write(i .. " ")
end
print()
-- 10 8 6 4 2 0

A variável do laço é local

A variável de controle do laço (i) é automaticamente local. Não é possível alterar seu valor dentro do laço — o Lua ignora atribuições à variável do laço. Para controlar as iterações de outra forma, use uma variável local separada.

for i = 1, 5 do
  -- i is read-only inside the loop
  -- i = i + 10  -- this creates a new global i, not the loop var
  print(i)  -- always 1, 2, 3, 4, 5 as expected
end
-- i is nil here (it was local to the loop)
print(i)  -- nil (or whatever global i was)

Percorrendo matrizes

O uso mais comum do for numérico é percorrer matrizes por índice. Use #arr como limite. Diferentemente de ipairs, essa forma permite controlar o tamanho do passo e percorrer a matriz na ordem inversa, além de ser um pouco mais rápida para matrizes densas.

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

for i = 1, #fruits do
  print(i, fruits[i])
end
-- 1  apple
-- 2  banana
-- 3  cherry
-- 4  date

Somando com for

Os laços for numéricos são ideais para acumular valores de matrizes. O padrão é sempre o mesmo: inicialize uma variável de resultado antes do laço, atualize-a dentro dele e use-a depois.

local values = {10, 20, 30, 40, 50}
local total = 0

for i = 1, #values do
  total = total + values[i]
end

print("Total:", total)    -- 150
print("Count:", #values)  -- 5
print("Mean:", total / #values)  -- 30

For numérico aninhado

Aninhe dois laços for numéricos para operações bidimensionais, como percorrer matrizes, trabalhar com tabelas de tabelas ou gerar pares de coordenadas. O laço externo percorre as linhas e o interno percorre as colunas — cada iteração acessa uma célula.

local rows, cols = 3, 4

for r = 1, rows do
  for c = 1, cols do
    io.write(string.format("%2d ", r * c))
  end
  print()
end
--  1  2  3  4
--  2  4  6  8
--  3  6  9 12

Passos decimais

O passo e os limites podem ser números de ponto flutuante, embora isso possa introduzir erros de precisão. Para obter contagens exatas de iterações, use inteiros. Se for necessário usar números de ponto flutuante, saiba que a quantidade de iterações é calculada como floor((limit - start) / step) + 1.

-- Float step
for x = 0.0, 1.0, 0.25 do
  io.write(x .. " ")
end
print()
-- 0.0  0.25  0.5  0.75  1.0

-- Prefer integer math when possible
for i = 0, 4 do
  local x = i * 0.25
  io.write(x .. " ")
end

Construindo uma tabela de resultados

Um laço for numérico é a forma padrão de construir uma nova tabela a partir de dados existentes. Crie uma tabela vazia e use o laço para preenchê-la por índice.

local source = {1, 2, 3, 4, 5}
local squares = {}

for i = 1, #source do
  squares[i] = source[i] ^ 2
end

for i = 1, #squares do
  print(squares[i])   -- 1, 4, 9, 16, 25
end

break em for numérico

É possível sair antecipadamente de um for numérico usando break. A execução salta para a instrução após end. Isso é útil em uma busca linear: percorra os elementos até encontrar o alvo e então use break.

local data = {5, 3, 8, 1, 9, 2, 7}
local target = 9
local foundAt = nil

for i = 1, #data do
  if data[i] == target then
    foundAt = i
    break
  end
end

if foundAt then
  print("Found at index " .. foundAt)  -- 5
else
  print("Not found")
end

Cálculo da quantidade de iterações

A quantidade de iterações de for i = start, limit, step é max(0, floor((limit - start) / step) + 1). Entender isso evita erros de deslocamento de uma posição. Quando o passo é 1, a quantidade é simplesmente limit - start + 1.

-- How many iterations?
local count = 0
for i = 1, 10, 3 do
  count = count + 1
end
print(count)   -- 4  (i = 1, 4, 7, 10)

count = 0
for i = 5, 1 do   -- step=1 but start > limit
  count = count + 1
end
print(count)   -- 0 (no iterations)

Verificação rápida

Quais valores são percorridos por for i = 10, 1, -3 do?

Recapitulação: for numérico

Resumo:

for i = start, limit, step do — o passo padrão é 1
Passo negativo para contagens regressivas
A variável do laço é automaticamente local e somente para leitura
O limite e o passo são avaliados uma vez antes do início do laço
break encerra o laço antecipadamente
Padrão comum: construir tabelas de resultados, pesquisar matrizes e acumular somas

Perguntas Frequentes

A aula “Laço for numérico” é grátis?

Sim — o texto completo de “Laço for numérico” é 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ço for numérico”?

Percorra intervalos numéricos com a sintaxe for i=start,limit,step. 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 “Laço for numérico”?

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

← Voltar para Lua Academy