Como funciona o laço while

O resultado: repetir até alcançar uma condição

O laço while executa um bloco enquanto uma condição for verdadeira. A condição é testada antes de cada iteração; portanto, o corpo pode executar zero, uma ou várias vezes.

Vamos construir um algoritmo hipotético que calcula quantos depósitos fixos são necessários para alcançar uma meta. Considere:

• meta de 500;
• saldo inicial de 120;
• depósito de 95 por iteração.

O resultado esperado é 4 depósitos e saldo final 500:

meta <- 500
saldo <- 120
deposito <- 95
quantidade <- 0

ENQUANTO saldo < meta FAÇA
  saldo <- saldo + deposito
  quantidade <- quantidade + 1
FIM ENQUANTO

EXIBIR quantidade
EXIBIR saldo

O algoritmo não sabe a quantidade de iterações antes de executar. Ele sabe a condição que precisa deixar de ser verdadeira: saldo < meta.

Construa o while em quatro passos

Em vez de começar pela palavra while, comece pelo estado e pelo resultado que precisa ser verdadeiro ao final.

1. Defina o estado anterior ao primeiro teste

O estado inicial contém tudo que a condição e o corpo precisam consultar:

meta <- 500
saldo <- 120
deposito <- 95
quantidade <- 0

meta e deposito permanecem estáveis neste exemplo. saldo e quantidade mudam. Inicializar quantidade fora do laço é necessário porque ela deve existir mesmo quando nenhuma iteração ocorrer.

2. Escreva a condição de continuidade

A pergunta feita antes de cada passagem é:

O saldo ainda está abaixo da meta?

Ela se transforma em:

saldo < meta

Esse operador relacional produz verdadeiro ou falso. Se o resultado for verdadeiro, o corpo executa. Se for falso, o fluxo segue para a primeira instrução após o laço.

Escreva a condição como uma regra de continuidade, não como uma descrição da saída. A saída desejada é saldo >= meta; o laço continua justamente enquanto essa pós-condição ainda não foi atingida.

3. Faça o corpo trabalhar e produzir progresso

O corpo realiza duas atualizações:

saldo <- saldo + deposito
quantidade <- quantidade + 1

A primeira aproxima o estado da saída. A segunda registra quantas passagens aconteceram. Se saldo não mudasse, saldo < meta continuaria verdadeira indefinidamente.

Antes de confiar no laço, relacione explicitamente condição e progresso:

• a condição observa saldo;
• cada iteração aumenta saldo em 95;
• a meta é finita;
• logo, o saldo alcançará ou ultrapassará a meta após uma quantidade finita de depósitos.

Esse argumento depende de deposito > 0. Se o depósito pudesse ser zero ou negativo, ele precisaria ser validado antes do laço.

4. Declare o que deve ser verdade após a saída

Quando o while termina normalmente, seu teste ficou falso. Negar saldo < meta produz:

saldo >= meta

Essa é a pós-condição do exemplo. Ela permite verificar o resultado sem depender apenas de uma saída específica. Com outros valores iniciais ou depósitos, a quantidade muda, mas o saldo final ainda precisa alcançar ou ultrapassar a meta.

Acompanhe cada teste, não apenas cada iteração

O exemplo realiza quatro iterações, mas avalia a condição cinco vezes. O último teste falso é o que autoriza a saída:

Teste	saldo antes do corpo	saldo < 500	Ação	quantidade depois
1	120	verdadeiro	depositar 95 → saldo 215	1
2	215	verdadeiro	depositar 95 → saldo 310	2
3	310	verdadeiro	depositar 95 → saldo 405	3
4	405	verdadeiro	depositar 95 → saldo 500	4
5	500	falso	sair sem executar o corpo	4

Faça o teste de mesa registrando o estado antes do corpo. Essa convenção deixa visível tanto o primeiro teste quanto o teste final falso.

Um erro comum é contar apenas quatro avaliações porque houve quatro depósitos. Em um while encerrado pela própria condição, existe uma avaliação adicional que descobre que não deve haver outra iteração.

A mesma lógica em Python, JavaScript e C#

A pontuação e os delimitadores mudam, mas o ciclo permanece: testar, executar, atualizar e testar novamente.

Python

meta = 500
saldo = 120
deposito = 95
quantidade = 0

while saldo < meta:
    saldo += deposito
    quantidade += 1

print(quantidade)  # 4
print(saldo)       # 500

Python delimita o corpo pela indentação. Todas as instruções recuadas pertencem ao laço.

JavaScript

const meta = 500;
let saldo = 120;
const deposito = 95;
let quantidade = 0;

while (saldo < meta) {
  saldo += deposito;
  quantidade += 1;
}

console.log(quantidade); // 4
console.log(saldo);      // 500

JavaScript envolve a condição em parênteses e agrupa o corpo entre chaves.

C#

decimal meta = 500m;
decimal saldo = 120m;
decimal deposito = 95m;
int quantidade = 0;

while (saldo < meta)
{
    saldo += deposito;
    quantidade += 1;
}

Console.WriteLine(quantidade); // 4
Console.WriteLine(saldo);      // 500

C# exige que a condição seja booleana e usa chaves para o bloco. O sufixo m representa literais decimal; aqui ele evita introduzir números binários de ponto flutuante em um exemplo de valores monetários.

Não tente memorizar três aparências como três algoritmos. Identifique em todas elas o mesmo estado, condição, corpo, atualização e saída.

Use while quando a condição determina a duração

O while comunica bem situações como:

• repetir enquanto uma fila possui trabalho;
• tentar novamente enquanto a entrada for inválida e houver tentativas;
• avançar enquanto um próximo estado existir;
• aproximar um valor de uma meta;
• executar enquanto um recurso permanecer disponível.

Ele é especialmente útil quando a pergunta natural é “enquanto isso for verdade, o que deve acontecer?” e a quantidade de passagens depende da evolução do estado.

Se a intenção principal for percorrer todos os itens de uma coleção, uma estrutura “para cada” costuma expressar melhor esse objetivo. Se início, limite e passo formarem uma contagem previsível, uma estrutura for pode reunir esses controles com mais clareza. Isso não significa que while seja incapaz de realizar esses percursos; significa que a estrutura escolhida deve tornar a intenção evidente.

Valide zero, uma, várias e nenhuma saída

Trocar os dados iniciais revela comportamentos diferentes do mesmo código:

saldo	meta	deposito	Iterações esperadas	Motivo
500	500	95	0	a condição começa falsa
450	500	95	1	um depósito basta
120	500	95	4	várias atualizações produzem progresso
120	500	0	não termina	o estado observado não muda

O primeiro caso é essencial. Como o teste acontece antes do corpo, um saldo que já alcançou a meta não recebe depósito e quantidade permanece zero. Esse comportamento diferencia while de estruturas cujo teste ocorre depois da primeira passagem.

No último caso, a correção não é impor um número arbitrário de iterações. A causa é uma entrada incompatível com a promessa de progresso. Valide deposito > 0 ou redefina o modelo do problema.

Diagnostique o laço pela relação entre condição e estado

Quando o resultado estiver errado, procure o sintoma e siga até a relação quebrada:

Sintoma	Pergunta de diagnóstico	Correção provável
corpo nunca executa	a condição já começa falsa?	revisar o estado inicial ou aceitar corretamente o caso zero
executa uma vez a mais	a condição inclui um limite que deveria excluir?	conferir <, <=, > e >=
nunca termina	qual valor observado pela condição deveria mudar?	garantir atualização e validar direção e passo
quantidade incorreta	o contador começa e é atualizado no lugar certo?	inicializar antes e incrementar uma vez por iteração
estado final ultrapassa a meta	ultrapassar é permitido pelo domínio?	aceitar a pós-condição ou ajustar o último passo conforme a regra real

Evite usar while verdadeiro com break como primeira solução. Essa forma pode ser válida quando a saída depende de um evento localizado no corpo, mas ela esconde a condição principal se usada sem necessidade.

Também tenha cuidado com continue: ele volta ao teste. Se a atualização necessária estiver abaixo dele, uma ramificação pode pular o progresso e repetir indefinidamente.

Pratique com tentativas limitadas

Construa um algoritmo para verificar um código enquanto estas duas condições forem verdadeiras:

• o código ainda não foi aceito;
• foram realizadas menos de três tentativas.

Comece com:

aceito <- falso
tentativas <- 0

Dentro do laço, leia uma tentativa, compare com o código esperado e atualize a quantidade. Depois da saída, diferencie dois resultados: código aceito ou limite atingido.

Teste quatro sequências:

1. código correto na primeira tentativa;
2. código correto na terceira;
3. três códigos incorretos;
4. estado inicial já aceito, que deve produzir zero iterações.

Para conferir sua solução, registre cada avaliação da condição composta e confirme que tentativas nunca ultrapassa três.

O que você deve guardar

O while testa uma condição antes de cada passagem. Construa-o a partir de quatro decisões: qual é o estado inicial, o que permite continuar, como o corpo produz progresso e o que deve ser verdade depois da saída.

Rastreie também o teste final falso; valide zero, uma e várias iterações; e trate entradas que impedem progresso. Agora veja como funciona o laço do while e o que muda quando o corpo precisa executar antes do primeiro teste.

Referências

• MDN Web Docs — while em JavaScript. Acesso em 11 set. 2026.
• Microsoft Learn — C# Language Specification: iteration statements. Acesso em 11 set. 2026.
• Microsoft Learn — Iteration statements: for, foreach, do e while. Acesso em 11 set. 2026.
• Python Documentation — Instrução while. Acesso em 11 set. 2026.