Neste artigo
- O que é um laço de repetição?
- Como funciona o while?
- Como funciona o for?
- O que são contador e acumulador?
- Como usar laços de repetição em Python, PHP e C?
- Para que servem break e continue?
- O que é o do-while?
- Como outras linguagens chamam os laços de repetição?
- Aí você pergunta: qual laço uso?
- O que é um laço infinito?
- Quais são os erros mais comuns com laços de repetição?
- Agora é com você!
Laço de repetição é o comando que faz o programa executar o mesmo bloco de instruções várias vezes, enquanto uma condição for verdadeira. Os dois laços que existem nas três linguagens deste blog se chamam while e for.
Este artigo junta duas peças que você já tem. Das variáveis vem o contador, que muda a cada volta. Da estrutura condicional vem o teste que decide se o laço continua. Com os laços, você passa a percorrer vetores e matrizes inteiros com poucas linhas.
Pense na pia depois do almoço. Ninguém escreve “lave o prato 1, lave o prato 2, lave o prato 3”. A instrução é uma só: enquanto houver prato sujo, lave um prato. Ela serve para 3 pratos ou para 30. Outra forma de repetir é a do treino: dê 10 voltas na quadra. Aqui você já sabe o número de voltas antes de começar. O while é a pia. O for é a quadra.

O que é um laço de repetição?
Uma estrutura de repetição permite que uma sequência de comandos seja executada repetidamente, enquanto determinadas condições são satisfeitas. Cada execução do bloco é chamada de volta ou iteração. Os programas passam a maior parte do tempo repetindo tarefas, seja até que uma condição aconteça, seja por um número fixo de vezes.
Como funciona o while?
O while tem uma condição e um bloco, como o if. A diferença está no que acontece depois do bloco: o programa volta e testa a condição de novo.
- A condição é avaliada no início de cada volta.
- Se for verdadeira, o bloco é executado e o programa retorna ao teste.
- Se for falsa, o laço termina. Se já for falsa na primeira vez, o bloco não é executado nenhuma vez.

Como funciona o for?
O for de C e de PHP reúne em uma linha as três coisas que todo laço com contador precisa: o início, a condição e o passo.
for (início; condição; passo) for (n = 1; n <= 100; n++)
- Início: executado uma única vez, antes da primeira volta.
- Condição: testada no começo de cada volta. Enquanto for verdadeira, o laço continua.
- Passo: executado no fim de cada volta. Normalmente atualiza o contador. O n++ é uma forma curta de escrever n = n + 1.
O for do Python é diferente: ele percorre os itens de uma sequência, na ordem em que aparecem. Para contar, usa-se a função range. ATENÇÃO: o ponto final do range nunca é incluído. range(5) gera 0, 1, 2, 3 e 4. Para ir de 1 a 100, escreve-se range(1, 101).
O que são contador e acumulador?
São dois papéis que uma variável pode ter dentro de um laço. O contador aumenta de 1 em 1 e responde “quantos?”. O acumulador soma um valor diferente a cada volta e responde “quanto deu no total?”. Os dois precisam de um valor inicial antes do laço, normalmente 0.

Ver a animação do laço somando de 1 a 5

Como usar laços de repetição em Python, PHP e C?
O programa tem seis trechos numerados: while, for com acumulador, contador, break, continue e um laço dentro de outro.
Python:
# Laços de repetição: while, for, break e continue
# 1. while: repete enquanto a condição for verdadeira
i = 1
while i <= 5:
print("volta", i)
i = i + 1 # sem esta linha, o laço nunca termina
# 2. for: o mesmo contador, com início, limite e passo em uma linha só
soma = 0
for n in range(1, 101): # de 1 a 100; o 101 fica de fora
soma = soma + n # acumulador: guarda o total parcial
print("soma de 1 a 100:", soma)
# 3. contador: quantos valores passam em um teste
notas = [7.5, 4.0, 9.0, 6.0, 3.5, 8.0]
aprovados = 0
for nota in notas:
if nota >= 6:
aprovados = aprovados + 1
print("aprovados:", aprovados, "de", len(notas))
# 4. break: sai do laço antes do fim
numero = 50
while True:
if numero % 7 == 0:
break
numero = numero + 1
print("primeiro múltiplo de 7 a partir de 50:", numero)
# 5. continue: pula o resto desta volta e vai para a próxima
linha = ""
for n in range(1, 11):
if n % 3 == 0:
continue
linha = linha + str(n) + " "
print("de 1 a 10 sem os múltiplos de 3:", linha)
# 6. laço dentro de laço: para cada linha, todas as colunas
for linha_tabela in range(1, 4):
texto = ""
for coluna in range(1, 4):
texto = texto + "%d x %d = %d " % (linha_tabela, coluna, linha_tabela * coluna)
print(texto)
PHP:
<?php
// Laços de repetição: while, for, break e continue
// 1. while: repete enquanto a condição for verdadeira
$i = 1;
while ($i <= 5) {
echo "volta $i\n";
$i = $i + 1; // sem esta linha, o laço nunca termina
}
// 2. for: o mesmo contador, com início, limite e passo em uma linha só
$soma = 0;
for ($n = 1; $n <= 100; $n++) { // de 1 a 100
$soma = $soma + $n; // acumulador: guarda o total parcial
}
echo "soma de 1 a 100: $soma\n";
// 3. contador: quantos valores passam em um teste
$notas = [7.5, 4.0, 9.0, 6.0, 3.5, 8.0];
$aprovados = 0;
foreach ($notas as $nota) {
if ($nota >= 6) {
$aprovados = $aprovados + 1;
}
}
echo "aprovados: $aprovados de " . count($notas) . "\n";
// 4. break: sai do laço antes do fim
$numero = 50;
while (true) {
if ($numero % 7 == 0) {
break;
}
$numero = $numero + 1;
}
echo "primeiro múltiplo de 7 a partir de 50: $numero\n";
// 5. continue: pula o resto desta volta e vai para a próxima
$linha = "";
for ($n = 1; $n <= 10; $n++) {
if ($n % 3 == 0) {
continue;
}
$linha = $linha . $n . " ";
}
echo "de 1 a 10 sem os múltiplos de 3: $linha\n";
// 6. laço dentro de laço: para cada linha, todas as colunas
for ($linha_tabela = 1; $linha_tabela <= 3; $linha_tabela++) {
$texto = "";
for ($coluna = 1; $coluna <= 3; $coluna++) {
$texto = $texto . sprintf("%d x %d = %d ", $linha_tabela, $coluna, $linha_tabela * $coluna);
}
echo $texto . "\n";
}
C:
/* Laços de repetição: while, for, break e continue */
#include <stdio.h>
int main(void) {
/* 1. while: repete enquanto a condição for verdadeira */
int i = 1;
while (i <= 5) {
printf("volta %d\n", i);
i = i + 1; /* sem esta linha, o laço nunca termina */
}
/* 2. for: o mesmo contador, com início, limite e passo em uma linha só */
int soma = 0;
for (int n = 1; n <= 100; n++) { /* de 1 a 100 */
soma = soma + n; /* acumulador: guarda o total parcial */
}
printf("soma de 1 a 100: %d\n", soma);
/* 3. contador: quantos valores passam em um teste */
double notas[] = {7.5, 4.0, 9.0, 6.0, 3.5, 8.0};
int quantidade = 6, aprovados = 0;
for (int k = 0; k < quantidade; k++) {
if (notas[k] >= 6) {
aprovados = aprovados + 1;
}
}
printf("aprovados: %d de %d\n", aprovados, quantidade);
/* 4. break: sai do laço antes do fim */
int numero = 50;
while (1) {
if (numero % 7 == 0) {
break;
}
numero = numero + 1;
}
printf("primeiro múltiplo de 7 a partir de 50: %d\n", numero);
/* 5. continue: pula o resto desta volta e vai para a próxima */
printf("de 1 a 10 sem os múltiplos de 3: ");
for (int n = 1; n <= 10; n++) {
if (n % 3 == 0) {
continue;
}
printf("%d ", n);
}
printf("\n");
/* 6. laço dentro de laço: para cada linha, todas as colunas */
for (int linha = 1; linha <= 3; linha++) {
for (int coluna = 1; coluna <= 3; coluna++) {
printf("%d x %d = %d ", linha, coluna, linha * coluna);
}
printf("\n");
}
return 0;
}
Saída:
volta 1 volta 2 volta 3 volta 4 volta 5 soma de 1 a 100: 5050 aprovados: 4 de 6 primeiro múltiplo de 7 a partir de 50: 56 de 1 a 10 sem os múltiplos de 3: 1 2 4 5 7 8 10 1 x 1 = 1 1 x 2 = 2 1 x 3 = 3 2 x 1 = 2 2 x 2 = 4 2 x 3 = 6 3 x 1 = 3 3 x 2 = 6 3 x 3 = 9
Mesma saída nas três linguagens. Foque no conceito, e não na linguagem!
No trecho 3, repare que Python e PHP percorrem a lista de notas diretamente, sem falar em posição. O PHP tem um comando próprio para isso, o foreach. Em C, o laço percorre os índices de 0 a 5 e busca cada nota pela posição.
No trecho 6, o laço de dentro dá suas três voltas completas para cada volta do laço de fora. São 3 x 3 = 9 execuções do bloco mais interno. Sacou? É assim que se percorre uma matriz.
Para que servem break e continue?
- break: encerra o laço na hora, e a execução passa para o primeiro comando depois dele. No trecho 4, não se sabe de antemão quantas voltas serão necessárias. O laço roda até achar o 56 e sai.
- continue: pula o restante da volta atual e segue para a próxima. No trecho 5, os múltiplos de 3 são pulados, mas o laço continua até o 10.
Quando há laços aninhados, o break sai apenas do laço mais interno em que ele está.
O que é o do-while?
C e PHP têm um terceiro laço. No do-while, a condição é verificada no fim de cada volta, e não no começo. A consequência é que o bloco sempre é executado pelo menos uma vez.
/* do-while: o bloco é executado antes do teste */
#include <stdio.h>
int main(void) {
int tentativas = 0;
int senha = 0;
do {
tentativas = tentativas + 1;
senha = senha + 1234; /* simula a senha digitada em cada tentativa */
printf("tentativa %d: senha %d\n", tentativas, senha);
} while (senha != 3702);
printf("acertou depois de %d tentativas\n", tentativas);
int contador = 10;
while (contador < 5) { /* a condição já começa falsa: nenhuma volta */
printf("while: nunca aparece\n");
}
do { /* o teste vem no fim: uma volta acontece */
printf("do-while: executou uma vez com contador = %d\n", contador);
} while (contador < 5);
return 0;
}
Saída:
tentativa 1: senha 1234 tentativa 2: senha 2468 tentativa 3: senha 3702 acertou depois de 3 tentativas do-while: executou uma vez com contador = 10
A última linha mostra a diferença. Com contador valendo 10, a condição contador < 5 é falsa desde o início. O while não deu nenhuma volta. O do-while deu uma.
Em Python, os comandos de repetição são o while e o for. O efeito de “executar e depois testar” se consegue com while True e um break, como no trecho 4.
Como outras linguagens chamam os laços de repetição?
Python, PHP e C usam quase os mesmos nomes: while, for e do-while. Em outras linguagens usadas no mercado, o laço ganha outros nomes, e algumas regras mudam junto. As sete linguagens abaixo estão na lista da pesquisa de 2026 do Stack Overflow com desenvolvedores. O Kotlin é a linguagem que o Google recomenda para começar um app Android, e o VBA, que roda dentro do Excel e dos outros programas do Office, usa o mesmo For … Next e o mesmo Do … Loop do Visual Basic.
O programa faz as mesmas três coisas nas sete linguagens: repete uma frase 3 vezes, conta de 5 até 1 e repete a senha do do-while até acertar. Troque de linguagem nas abas do quadro de código.
// Laços de repetição em Go: só existe o for
package main
import "fmt"
func main() {
// Repetir 3 vezes: for range 3 (Go 1.22 ou mais novo)
for range 3 {
fmt.Print("Toc! ")
}
fmt.Println("Quem é?")
// Contar de 5 até 1: for só com a condição é o while do Go
i := 5
for i >= 1 {
fmt.Print(i, " ")
i--
}
fmt.Println("Fogo!")
// Repetir até acertar: for sem condição é laço sem fim, e o break encerra
tentativas := 0
senha := 0
for {
tentativas++
senha += 1234 // simula a senha digitada em cada tentativa
fmt.Printf("tentativa %d: senha %d\n", tentativas, senha)
if senha == 3702 {
break
}
}
fmt.Printf("acertou depois de %d tentativas\n", tentativas)
}
// Laços de repetição em Kotlin: repeat, downTo e do-while
fun main() {
// Repetir 3 vezes: repeat é uma função, não uma palavra reservada
repeat(3) {
print("Toc! ")
}
println("Quem é?")
// Contar de 5 até 1: o intervalo 5 downTo 1 conta para trás
for (i in 5 downTo 1) {
print("$i ")
}
println("Fogo!")
// Repetir até acertar: o mesmo do-while do C
var tentativas = 0
var senha = 0
do {
tentativas++
senha += 1234 // simula a senha digitada em cada tentativa
println("tentativa $tentativas: senha $senha")
} while (senha != 3702)
println("acertou depois de $tentativas tentativas")
}
// Laços de repetição em Rust: for com intervalos e loop com valor
fn main() {
// Repetir 3 vezes: 0..3 vai de 0 a 2 (o 3 fica de fora)
for _ in 0..3 {
print!("Toc! ");
}
println!("Quem é?");
// Contar de 5 até 1: 1..=5 inclui o 5, e rev() inverte a ordem
for i in (1..=5).rev() {
print!("{i} ");
}
println!("Fogo!");
// Repetir até acertar: loop é o laço sem fim, e o break devolve um valor
let mut vez = 0;
let mut senha = 0;
let tentativas = loop {
vez += 1;
senha += 1234; // simula a senha digitada em cada tentativa
println!("tentativa {vez}: senha {senha}");
if senha == 3702 {
break vez;
}
};
println!("acertou depois de {tentativas} tentativas");
}
# Laços de repetição em Ruby: times, downto e until
# Repetir 3 vezes: times é um método do número 3
3.times do
print "Toc! "
end
puts "Quem é?"
# Contar de 5 até 1: downto, outro método do número
5.downto(1) do |i|
print i, " "
end
puts "Fogo!"
# Repetir até acertar: until repete enquanto a condição for falsa
tentativas = 0
senha = 0
until senha == 3702
tentativas += 1
senha += 1234 # simula a senha digitada em cada tentativa
puts "tentativa #{tentativas}: senha #{senha}"
end
puts "acertou depois de #{tentativas} tentativas"
' Laços de repetição em Visual Basic: For ... Next e Do ... Loop
Module Lacos
Sub Main()
' Repetir 3 vezes: For ... To ... Next
For i As Integer = 1 To 3
Console.Write("Toc! ")
Next
Console.WriteLine("Quem é?")
' Contar de 5 até 1: Step -1 faz o contador descer
For i As Integer = 5 To 1 Step -1
Console.Write(i & " ")
Next
Console.WriteLine("Fogo!")
' Repetir até acertar: Loop Until testa no fim, como o do-while
Dim tentativas As Integer = 0
Dim senha As Integer = 0
Do
tentativas = tentativas + 1
senha = senha + 1234 ' simula a senha digitada em cada tentativa
Console.WriteLine("tentativa " & tentativas & ": senha " & senha)
Loop Until senha = 3702
Console.WriteLine("acertou depois de " & tentativas & " tentativas")
End Sub
End Module
// Laços de repetição em Delphi: for ... downto e repeat ... until
program Lacos;
var
i, tentativas, senha: Integer;
begin
// Repetir 3 vezes: for ... to ... do
for i := 1 to 3 do
Write('Toc! ');
WriteLn('Quem é?');
// Contar de 5 até 1: downto faz o contador descer
for i := 5 downto 1 do
Write(i, ' ');
WriteLn('Fogo!');
// Repetir até acertar: repeat ... until testa no fim
tentativas := 0;
senha := 0;
repeat
tentativas := tentativas + 1;
senha := senha + 1234; // simula a senha digitada em cada tentativa
WriteLn('tentativa ', tentativas, ': senha ', senha);
until senha = 3702;
WriteLn('acertou depois de ', tentativas, ' tentativas');
end.
* Laços de repetição em COBOL: o verbo PERFORM
IDENTIFICATION DIVISION.
PROGRAM-ID. LACOS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 I PIC 9.
01 TENTATIVAS PIC 9 VALUE 0.
01 SENHA PIC 9(4) VALUE 0.
PROCEDURE DIVISION.
* Repetir 3 vezes: PERFORM ... TIMES, sem contador
PERFORM 3 TIMES
DISPLAY "Toc! " WITH NO ADVANCING
END-PERFORM
DISPLAY "Quem é?"
* Contar de 5 até 1: VARYING ... BY -1 desce de 1 em 1
PERFORM VARYING I FROM 5 BY -1 UNTIL I < 1
DISPLAY I " " WITH NO ADVANCING
END-PERFORM
DISPLAY "Fogo!"
* Repetir até acertar: WITH TEST AFTER testa no fim
PERFORM WITH TEST AFTER UNTIL SENHA = 3702
ADD 1 TO TENTATIVAS
ADD 1234 TO SENHA
DISPLAY "tentativa " TENTATIVAS ": senha " SENHA
END-PERFORM
DISPLAY "acertou depois de " TENTATIVAS " tentativas"
STOP RUN.
Saída:
Toc! Toc! Toc! Quem é? 5 4 3 2 1 Fogo! tentativa 1: senha 1234 tentativa 2: senha 2468 tentativa 3: senha 3702 acertou depois de 3 tentativas
Mesma saída nas sete linguagens. Foque no conceito, e não na linguagem!
O que muda é o nome de cada ideia:
- Repetir um número fixo de vezes: repeat(3) no Kotlin, 3.times no Ruby e PERFORM 3 TIMES no COBOL, sem variável de contador. No Kotlin, repeat é uma função da biblioteca padrão, e no Ruby, times é um método do próprio número. O Go passou a aceitar for range 3 na versão 1.22.
- Um nome só para tudo: o Go não tem while nem do-while. O for só com a condição faz o papel do while, e o for sem condição nenhuma repete sem fim, até um break.
- Contar para trás: 5 downTo 1 no Kotlin, 5.downto(1) no Ruby, (1..=5).rev() no Rust, Step -1 no Visual Basic, downto no Delphi e BY -1 no COBOL.
- Repetir até: o until do Ruby, o Loop Until do Visual Basic, o repeat … until do Delphi e o UNTIL do COBOL repetem até a condição ficar verdadeira. O Loop Until, o repeat … until e o WITH TEST AFTER testam no fim, como o do-while. O until do Ruby testa no começo, como o while.
- Laço que devolve um valor: no Rust, loop repete sem fim, e o break pode levar um valor para fora. No programa, o número de tentativas sai do próprio laço.
ATENÇÃO: o until inverte a condição. No do-while do C, senha != 3702 diz quando continuar. No until, a condição diz quando parar: senha = 3702. Copie a condição do C sem inverter e o programa erra sem avisar. No Visual Basic, Loop Until senha <> 3702 para depois da primeira tentativa e imprime “acertou depois de 1 tentativas” com a senha errada. No Ruby, until senha != 3702 nem entra no laço e imprime “acertou depois de 0 tentativas”.
ATENÇÃO: o mesmo 1..5 não dá o mesmo número de voltas em todas. No Kotlin e no Ruby, 1..5 vai de 1 a 5: são 5 voltas. No Rust, 1..5 para no 4: são 4 voltas, e para incluir o 5 você escreve 1..=5, como na contagem regressiva do programa. Para deixar o último de fora, o Kotlin usa 1..<5 e o Ruby usa três pontos, 1...5. Sacou? Quem troca de linguagem sem conferir isso erra por um.
Aí você pergunta: qual laço uso?
- for: quando você sabe quantas voltas serão, ou quando vai percorrer uma lista do começo ao fim.
- while: quando a quantidade de voltas depende do que acontece durante a execução, e o teste precisa ser feito antes da primeira volta.
- do-while: quando o bloco precisa rodar uma vez antes de o teste fazer sentido.
Um for com contador pode ser reescrito como while. O trecho 1 do programa é um for escrito à mão: início antes do laço, condição no while e passo na última linha do bloco.
O que é um laço infinito?
É o laço cuja condição nunca fica falsa. O programa entra na repetição e não sai mais. ATENÇÃO: algo dentro do bloco precisa ser capaz de mudar o resultado da condição. No trecho 1, é a linha i = i + 1. Apague essa linha e o programa imprimirá “volta 1” sem parar.
Em C existe uma armadilha: o ponto e vírgula logo depois da condição, como em while (a < 10); seguido do bloco. O ponto e vírgula encerra o comando ali, o laço fica sem corpo e a variável nunca muda.
Nem todo laço sem fim é erro. O while True do trecho 4 é proposital, e a saída é garantida pelo break. O problema é o laço infinito que você não planejou.
Quais são os erros mais comuns com laços de repetição?
- Esquecer de atualizar a variável da condição. É assim que nasce o laço infinito.
- Errar por um. Trocar <= por < faz o laço dar uma volta a menos. Em Python, esquecer que o range não inclui o ponto final dá o mesmo resultado.
- Não dar valor inicial ao contador ou ao acumulador. A soma precisa começar em 0.
- Zerar o acumulador dentro do laço. Se soma = 0 estiver dentro do bloco, o total recomeça a cada volta.
- Colocar ponto e vírgula depois do while ou do for em C. O laço fica sem corpo.
- Confundir break com continue. O break sai do laço. O continue só pula uma volta.
- Usar continue antes de atualizar o contador em um while. A volta é pulada, o contador não muda e o laço trava.
Agora é com você!
No papel:
- Faça a tabela de n e soma para o laço que soma os números de 1 a 6. O total deve ser 21.
- Quantas vezes a mensagem aparece em for (i = 0; i < 10; i = i + 2)? Liste os valores de i.
- No laço while do trecho 1, o que muda na saída se a condição for i < 5?
No computador:
- Mostre a tabuada do 7, de 7 x 1 até 7 x 10.
- Some apenas os números pares de 1 a 100. O resultado deve ser 2550.
- Dada a lista de notas do artigo, calcule a média usando um acumulador e um contador.
Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!
Até o próximo artigo!
Confiança Sempre!!!
Fontes:
- Manual do PHP, while, com a avaliação da condição no início de cada iteração e o caso em que o bloco não é executado nenhuma vez.
- Manual do PHP, for, com o papel das três expressões do for e o momento em que cada uma é avaliada.
- Manual do PHP, do-while, com a verificação da condição ao final de cada iteração.
- Manual do PHP, continue, com o salto do restante da iteração atual.
- Documentação do Python, More Control Flow Tools, com o for que percorre sequências, a função range sem o ponto final e os comandos break e continue (em inglês).
- Unicamp, Instituto de Computação, MC102, Comandos de Repetição, com while, for, break, continue e laços aninhados em Python (PDF, slides de aula).
- Universidade Federal de Uberlândia, Linguagem C: Comandos de Repetição, com a definição de estrutura de repetição e o laço infinito (PDF, slides de aula).
- Universidade Federal de Pernambuco, Centro de Informática, Estruturas de Repetição, com os três laços de C, a necessidade de modificar a condição dentro do laço, o break, o continue e a escolha entre while e do-while (PDF, slides de aula).
- Instituto Federal do Paraná, Lógica de Programação, Estruturas de Repetição, com o laço while executando um comando enquanto a condição for verdadeira (PDF, slides de aula).
- Unicamp, Instituto de Computação, MC102, notas de aula sobre estruturas de repetição, com a observação de que os programas passam a maior parte do tempo repetindo tarefas (PDF).
- Universidade Federal de Pernambuco, Centro de Informática, Linguagem de Programação C, Aula 3, com o exemplo do ponto e vírgula depois do while que gera um loop infinito (PDF, slides de aula).
- ACM, CS2013, Software Development Fundamentals, com as estruturas de controle iterativas entre os conceitos fundamentais de programação (em inglês).
- Stack Overflow, Developer Survey 2026, Programming, scripting, and markup languages, com Go, Kotlin, Rust, Ruby, Visual Basic (.Net), VBA, Delphi e COBOL na lista de linguagens dos participantes (em inglês).
- Android Developers, Android’s Kotlin-first approach, com a recomendação de começar um app Android em Kotlin (em inglês).
- Microsoft Learn, Office VBA, Using For…Next statements, com o For … Next do VBA e o Step negativo para o contador descer (em inglês).
- Microsoft Learn, Office VBA, Do…Loop statement, com o Do … Loop do VBA e as condições While e Until (em inglês).
- The Go Programming Language Specification, For statements, com as formas do for e a condição ausente equivalente a true (em inglês).
- Go 1.22 Release Notes, com o for que percorre um número inteiro, como em for range 3 (em inglês).
- Kotlin, biblioteca padrão, repeat, com repeat como função que executa a ação o número de vezes informado (em inglês).
- Kotlin, Ranges and progressions, com os intervalos .. e ..<, o downTo e o step (em inglês).
- The Rust Programming Language, Control Flow, com o loop que repete até um break e o break que devolve um valor (em inglês).
- The Rust Reference, Range expressions, com o intervalo .. que deixa o fim de fora e o ..= que o inclui (em inglês).
- Rust, biblioteca padrão, Rev, com o rev, que inverte a direção de um iterador (em inglês).
- Ruby 3.3, Integer, com os métodos times e downto (em inglês).
- Ruby, Control Expressions, com o until, que repete enquanto a condição for falsa e testa a condição ao entrar no laço (em inglês).
- Ruby 3.3, Range, com o .. que inclui o fim e o ... que o deixa de fora (em inglês).
- Microsoft Learn, For…Next Statement (Visual Basic), com o Step negativo que faz o contador descer (em inglês).
- Microsoft Learn, Do…Loop Statement (Visual Basic), com While e Until e o teste no começo ou no fim do laço (em inglês).
- Embarcadero DocWiki, Declarations and Statements (Delphi), com o for … downto e o repeat … until, que testa a condição depois de cada volta (em inglês).
- IBM, Enterprise COBOL, Coding a loop, com PERFORM … TIMES e PERFORM … WITH TEST AFTER … UNTIL (em inglês).
- IBM, Enterprise COBOL, PERFORM with VARYING phrase, com o VARYING que aumenta ou diminui o contador e o TEST BEFORE como padrão (em inglês).
- Os exemplos foram executados em Python 3.13, PHP 8.3, GCC 13, Go 1.24, Kotlin 2.4, Rust 1.97, Ruby 3.3, Visual Basic no .NET 8, Free Pascal 3.2 (no modo Delphi) e GnuCOBOL 3.1.

Continue a conversa