Laço de repetição e contador: repetir sem copiar código

Laço de repetição executa o mesmo trecho enquanto uma condição permite; contador registra quantas voltas ocorreram ou qual posição está sendo processada. Todo laço precisa deixar claro onde começa, até quando continua e como se aproxima do fim.

O domínio é a separação de dez pedidos de uma papelaria. Copiar dez chamadas cria dez lugares para errar. Um laço mantém uma regra e muda somente o estado necessário.

O trecho que se repete e a condição que manda parar

O menor while começa em um, verifica o limite e incrementa:

let pedido = 1;

while (pedido <= 3) {
  console.log(`separando pedido ${pedido}`);
  pedido += 1;
}

Pense num funcionário que olha a fila antes de pegar o próximo pedido. A analogia termina porque um laço pode processar dados sem ordem física e pode alterar mais de um estado. O ponto útil é: a pergunta ocorre antes de cada volta.

As três perguntas de todo laço

Registre início, condição e passo como dados antes de escrever a sintaxe:

const plano = {
  inicio: 1,
  condicao: 'pedido <= 10',
  passo: 'pedido += 1',
};

console.log(Object.values(plano).join(' | '));

O início define o primeiro estado; a condição decide se o corpo executa; o passo deve aproximar a condição de falso. Se uma dessas respostas faltar, pare antes de rodar.

Enquanto e para escrevem a mesma contagem

Quando as três partes cabem numa linha, for reúne a estrutura:

const comWhile = [];
let i = 1;
while (i <= 3) {
  comWhile.push(i);
  i += 1;
}

const comFor = [];
for (let j = 1; j <= 3; j += 1) comFor.push(j);

console.log(comWhile);
console.log(comFor);

Não existe vencedor universal. Escolha a forma que torna visível a condição de parada. Converter um no outro é um bom teste de entendimento.

Contador é estado, não decoração

O contador pode representar volta e posição. Imprima valor, resultado da condição e total executado:

let voltas = 0;
for (let i = 0; i <= 10; i += 1) {
  voltas += 1;
  console.log(`i=${i} condição=${i <= 10} voltas=${voltas}`);
}
console.log(`total=${voltas}`);

Começar em zero e incluir dez gera onze valores. A tabela de rastreio conta estados, não a distância entre extremos.

O erro de um a mais

Se o requisito diz “dez voltas a partir de zero”, o último índice é nove:

let voltas = 0;
for (let i = 0; i < 10; i += 1) voltas += 1;

console.log(voltas);

Trocar <= por < corrige este caso porque o limite representa quantidade, não valor final incluído. Em intervalos reais, escreva exemplos das duas bordas antes de escolher o operador.

O laço infinito e a mudança esquecida

Um while (i <= 3) sem incremento nunca muda a pergunta. Para reproduzir o defeito sem travar a máquina, adicionamos um fusível de diagnóstico:

let i = 1;
let voltas = 0;

while (i <= 3) {
  voltas += 1;
  if (voltas === 1_000_000) break;
}

console.log({ i, voltas, condicaoAindaVerdadeira: i <= 3 });

O milhão de voltas foi executado no Node, mas o fusível pertence ao diagnóstico, não à solução. A correção é alterar i no corpo ou redesenhar a condição.

Parar no meio quando a resposta já apareceu

Numa busca, continuar depois de encontrar desperdiça trabalho. break encerra o laço:

const pedidos = ['P10', 'P11', 'P12', 'P13'];
let comparacoes = 0;

for (const pedido of pedidos) {
  comparacoes += 1;
  if (pedido === 'P12') break;
}

console.log(comparacoes);

O critério é objetivo: depois de encontrar P12, nenhum elemento seguinte pode mudar a resposta. A complexidade de algoritmo transforma essa economia em contagem de passos.

Tabuada e contagem regressiva

Uma tabuada usa contador crescente; um lançamento usa contador decrescente. A regra é a mesma, mas o passo muda de sinal:

for (let i = 1; i <= 3; i += 1) console.log(`7 x ${i} = ${7 * i}`);
for (let segundos = 3; segundos >= 1; segundos -= 1) console.log(segundos);
console.log('lançar');

Missão: preveja antes de executar

Escreva a tabuada completa do 7 e uma contagem de 10 a 0. Antes de rodar, anote primeiro valor, último valor e total de voltas. Depois faça o programa conferir sua previsão:

const resultados = [];
for (let i = 1; i <= 10; i += 1) resultados.push(7 * i);

console.log({ primeiro: resultados[0], ultimo: resultados.at(-1), voltas: resultados.length });

Revise o laço separando avaliação e execução. A condição é consultada uma vez a mais que o corpo no término normal: a última consulta retorna falso. Essa diferença explica por que logs colocados apenas no corpo não mostram o estado que encerrou a repetição.

Também registre a variante do laço. Se percorre uma coleção que pode mudar durante a execução, adicionar ou remover itens altera quantidade e índices. Prefira produzir uma nova coleção ou documentar cuidadosamente a mutação. Um laço correto para dados estáveis pode falhar quando o próprio corpo modifica o limite.

Em processamento grande, não use break para esconder várias condições de saída espalhadas. Uma interrupção por resposta encontrada é clara; cinco interrupções por estados desconexos pedem função menor ou condição redesenhada. O teste precisa cobrir término normal e cada interrupção antecipada.

Por fim, compare quantidade prevista e observada com entradas zero, um e muitas. Esses três tamanhos expõem inicialização, primeira volta e crescimento. Se uma lista vazia ainda executa o corpo, a condição de entrada está errada.

Anote o custo por volta. Um laço com consulta remota ou busca completa dentro do corpo pode crescer muito mais que o contador sugere. Primeiro prove a correção do fluxo; depois conte o trabalho interno e escolha se dados podem ser preparados uma vez antes da repetição.

Termine quando previsão e saída coincidirem. Em seguida, use um acumulador para calcular média, percorra vetores e matrizes, revise combinações na tabela verdade e mantenha o guia de lógica como mapa.