Como funciona o laço do while

A diferença aparece antes mesmo de escrever o código

O laço do while executa o corpo primeiro e testa a condição depois. Por isso, realiza uma ou mais iterações, mesmo quando a condição já seria falsa no estado inicial.

Compare uma condição falsa desde o começo:

condicao <- falso

ENQUANTO condicao FAÇA
  executar ação
FIM ENQUANTO

O corpo acima executa zero vezes. Agora mude a posição do teste:

condicao <- falso

FAÇA
  executar ação
ENQUANTO condicao

O corpo executa uma vez e só então descobre que não deve repetir. Essa é a decisão central: a primeira passagem faz sentido antes de conhecer ou avaliar a condição de continuidade?

while testa antes; do while testa depois

As duas estruturas repetem enquanto uma condição for verdadeira. O que muda é a ordem.

Estrutura	Primeira operação	Quantidade mínima	Use quando
while	testar a condição	0	é válido não executar o corpo
do while	executar o corpo	1	a primeira passagem é necessária para produzir ou obter o estado testado

No laço while, o fluxo é:

teste → corpo → teste → corpo → ... → saída

No do while, a ordem é:

corpo → teste → corpo → teste → ... → saída

A condição ainda é uma regra de continuidade. Em FAÇA ... ENQUANTO opcao != 0, verdadeiro significa repetir e falso significa sair. A palavra “enquanto” não muda de sentido; somente muda de posição.

A primeira execução precisa ser parte correta do problema

Executar ao menos uma vez não é automaticamente uma vantagem. É uma garantia que precisa corresponder ao domínio.

Um do while pode representar bem estas situações:

• exibir um menu antes de perguntar se ele deve continuar;
• solicitar uma entrada antes de verificar se outra tentativa é necessária;
• realizar uma jogada antes de testar o encerramento de um turno;
• produzir um valor antes de decidir se o processo deve gerar outro.

Ele tende a representar mal situações em que o estado inicial pode dispensar completamente a ação:

• cobrar uma parcela quando a dívida já está quitada;
• retirar um item quando a fila pode começar vazia;
• enviar uma mensagem quando o destinatário pode não existir;
• processar uma posição antes de confirmar que a coleção possui elementos.

Antes de escolher, pergunte: se o processo já estiver concluído, vazio ou bloqueado, executar o corpo uma vez ainda será correto e seguro? Se a resposta for não, teste antes.

Construa um menu que precisa aparecer ao menos uma vez

Considere um menu hipotético:

1 - Consultar saldo
2 - Emitir relatório
0 - Sair

Não existe uma opção antes da primeira leitura. O algoritmo precisa exibir o menu e receber um valor para então decidir se haverá outra passagem:

FAÇA
  EXIBIR menu
  LER opcao

  SE opcao = 1 ENTÃO
    consultar saldo
  SENÃO SE opcao = 2 ENTÃO
    emitir relatório
  SENÃO SE opcao != 0 ENTÃO
    EXIBIR "Opção inválida"
  FIM SE
ENQUANTO opcao != 0

Observe três responsabilidades diferentes:

1. o corpo produz opcao por meio da leitura;
2. a decisão interna trata o valor escolhido;
3. a condição final decide se o menu será exibido novamente.

A opção 0 não executa uma operação interna. Ao chegar ao teste final, opcao != 0 é falsa e o fluxo sai.

Rastreie o corpo antes de registrar o teste

Suponha que a pessoa escolha 2, depois 9 e finalmente 0:

Iteração	Opção lida	Ação no corpo	Teste opcao != 0	Próximo passo
1	2	emitir relatório	verdadeiro	repetir
2	9	informar opção inválida	verdadeiro	repetir
3	0	não executar operação	falso	sair

No teste de mesa, registre primeiro o que o corpo produziu e depois o resultado da condição. Essa convenção acompanha a ordem real do do while.

Leia a sintaxe sem inverter a lógica

JavaScript

Usando funções hipotéticas de interface, a estrutura fica assim:

let opcao;

do {
  mostrarMenu();
  opcao = lerOpcao();
  processarOpcao(opcao);
} while (opcao !== 0);

Em JavaScript, a condição fica entre parênteses e existe um ponto e vírgula depois de while (...). O valor é atribuído dentro do corpo antes de ser testado.

C#

int opcao;

do
{
    MostrarMenu();
    opcao = LerOpcao();
    ProcessarOpcao(opcao);
}
while (opcao != 0);

C# também exige uma expressão booleana no teste posterior. Chaves delimitam o corpo e o ponto e vírgula encerra a instrução.

Nos dois exemplos, processarOpcao deve tratar 0 como comando de saída e não como uma operação comum. Separar leitura, processamento e continuidade torna esse contrato verificável.

Python representa o comportamento sem uma instrução do while

A gramática atual do Python oferece while, mas não uma instrução do while. Uma equivalência comum executa um laço deliberadamente aberto e testa a saída no fim do corpo:

while True:
    mostrar_menu()
    opcao = ler_opcao()
    processar_opcao(opcao)

    if opcao == 0:
        break

O break encerra o laço depois da primeira leitura e das passagens seguintes. Esse código reproduz a ordem corpo → teste de saída.

Existe uma diferença de leitura: na estrutura nativa, opcao != 0 expressa diretamente a condição de continuidade. Na equivalência Python, opcao == 0 expressa a condição de saída. Confundir as duas pode inverter o comportamento.

Não use while True sem tornar o caminho de saída próximo, visível e testável. Se a linguagem possui uma solução mais direta para o problema, clareza vale mais do que imitar a aparência de outra linguagem.

Compare pelo efeito da primeira passagem

Use esta sequência de decisão:

1. O estado necessário à condição já existe? Se não existe até o corpo ler ou produzir um valor, o teste posterior pode simplificar o fluxo.
2. Executar uma vez é sempre seguro? Se houver um estado inicial que proíbe a ação, prefira teste anterior.
3. A condição descreve continuidade com clareza? Evite dupla negação ou uma saída escondida entre muitas decisões.
4. A linguagem oferece a estrutura? Caso contrário, represente a ordem explicitamente sem forçar uma tradução literal.
5. Outra abstração comunica melhor? Eventos, funções ou iteração por coleção podem ser mais adequados em sistemas reais.

O menu é um bom exemplo didático porque “mostrar e ler” precisa ocorrer antes de “repetir?”. Em uma interface gráfica real, porém, cliques normalmente são tratados por eventos; manter um laço bloqueando a interface seria uma decisão arquitetural inadequada. O exemplo ensina ordem de controle, não prescreve toda implementação de interface.

Evite erros específicos do teste posterior

Executar um efeito indevido na primeira passagem

Se a condição deveria impedir uma cobrança, remoção ou envio, testá-la apenas depois é tarde. Escolha while ou faça uma verificação anterior explícita.

Inverter continuidade e saída

Em do ... while (opcao != 0), a condição verdadeira repete. Escrever opcao == 0 repetiria justamente quando a intenção era encerrar.

Usar um valor antigo no teste

O corpo deve atualizar ou produzir o estado consultado. Testar uma variável diferente daquela preenchida pela leitura quebra a ligação entre ação e decisão.

Processar o comando de saída como operação

No menu, 0 precisa ser reconhecido antes de uma ação genérica. Caso contrário, a última passagem pode produzir uma mensagem de erro ou um efeito indesejado antes de sair.

Acreditar que a primeira passagem garante o término

O do while garante uma execução mínima, não uma execução máxima. Se a condição continuar verdadeira e o estado não progredir, o laço ainda pode ser infinito.

Colocar continue antes de uma atualização necessária

Em do while, continue transfere o fluxo para o teste posterior. Confirme que todas as informações usadas pela condição estão em um estado válido antes desse desvio.

Pratique com confirmação de operação

Crie um algoritmo que mostre um resumo e solicite S para confirmar ou N para cancelar. Qualquer outro valor deve informar o erro e pedir novamente.

O corpo precisa executar ao menos uma vez porque ainda não existe resposta. Use uma condição composta para repetir enquanto a resposta for diferente de S e diferente de N.

Teste:

• S na primeira passagem;
• N na primeira passagem;
• dois valores inválidos seguidos de S;
• diferenças entre letras minúsculas e maiúsculas conforme a regra escolhida;
• entrada vazia, definindo explicitamente como será tratada.

Depois, reescreva com while. Observe que será necessário obter uma resposta antes do primeiro teste ou criar um estado inicial que force a primeira entrada. Compare qual versão comunica melhor a intenção.

O que você deve guardar

O do while executa o corpo antes de testar a continuidade. Isso garante uma ou mais passagens e o torna adequado quando a primeira ação precisa produzir o estado que será avaliado.

Escolha pela correção da primeira execução, não pela preferência de sintaxe. Compare o efeito quando a condição seria inicialmente falsa, deixe o caminho de saída visível e teste também estados que tornam a primeira ação indevida. Agora aprenda como funciona o laço for e organize inicialização, condição e atualização em uma progressão controlada.

Referências

• MDN Web Docs — do...while em JavaScript. Acesso em 11 set. 2026.
• Microsoft Learn — C# Language Specification: the do statement. Acesso em 11 set. 2026.
• Microsoft Learn — Iteration statements: for, foreach, do e while. Acesso em 11 set. 2026.
• Python Documentation — Compound statements. Acesso em 11 set. 2026.