O laço for é uma das estruturas de repetição mais utilizadas em JavaScript, pois oferece uma sintaxe compacta e controlada para iterar um número determinado de vezes. Diferente do while, o for concentra a inicialização, a condição e a atualização do contador em uma única linha, o que torna o código mais legível e menos propenso a erros. Nesta aula, exploraremos cada parte dessa estrutura, desde o básico até técnicas avançadas como interrupção de loops e aninhamento.

Dominar o laço for é essencial para percorrer arrays, executar tarefas repetitivas e implementar algoritmos que exigem iterações controladas. Vamos começar pela sua sintaxe fundamental.

Estrutura

A sintaxe do for é composta por três expressões opcionais separadas por ponto e vírgula, dentro de parênteses, seguidas por um bloco de código. A forma geral é:

for (inicialização; condição; atualização) {
  // código a ser executado em cada iteração
}

A inicialização é executada uma vez antes do início do loop. Geralmente declara e atribui um valor a uma variável contadora. A condição é avaliada antes de cada iteração; se for verdadeira, o bloco é executado; se falsa, o loop termina. A atualização é executada ao final de cada iteração, normalmente para incrementar ou decrementar o contador.

Exemplo básico que imprime números de 0 a 4:

for (let i = 0; i < 5; i++) {
  console.log(i);
}
// Saída: 0, 1, 2, 3, 4

Qualquer uma das três expressões pode ser omitida, mas os ponto e vírgula são obrigatórios. Por exemplo, um loop infinito: for (;;) { }. É importante garantir que a condição se torne falsa em algum momento para evitar loops infinitos.

Contadores

O contador é a variável que controla o número de iterações. Pode ser inicializado com qualquer valor, e a condição e atualização devem ser coerentes com o objetivo. Além do incremento simples (i++), é possível usar decremento, incremento de mais de uma unidade, ou até mesmo operações mais complexas.

Exemplos de contadores:

// Decremento: de 10 até 1
for (let i = 10; i > 0; i--) {
  console.log(i);
}

// Incremento de 2 em 2
for (let i = 0; i < 10; i += 2) {
  console.log(i); // 0, 2, 4, 6, 8
}

// Usando uma variável externa
let passo = 3;
for (let i = 0; i < 9; i += passo) {
  console.log(i); // 0, 3, 6
}

É comum usar let para declarar o contador dentro do for, pois o escopo da variável fica limitado ao bloco. Evite usar var para evitar vazamento de escopo.

break e continue

Os comandos break e continue permitem controlar o fluxo do loop de forma mais granular.

break: encerra imediatamente o loop, independentemente da condição. É útil para interromper a execução quando um determinado critério é atendido.

for (let i = 0; i < 10; i++) {
  if (i === 5) {
    break;
  }
  console.log(i);
}
// Saída: 0, 1, 2, 3, 4

continue: pula o restante do código na iteração atual e vai para a próxima iteração (executando a atualização e testando a condição).

for (let i = 0; i < 5; i++) {
  if (i === 2) {
    continue;
  }
  console.log(i);
}
// Saída: 0, 1, 3, 4

Esses comandos são especialmente úteis em loops aninhados, mas é preciso cuidado para não tornar o código confuso.

Laços aninhados

Um laço aninhado é um for dentro de outro for. É comum para percorrer matrizes bidimensionais ou gerar combinações. Cada iteração do loop externo executa o loop interno completamente.

Exemplo: imprimir uma tabuada de 1 a 3.

for (let i = 1; i <= 3; i++) {
  for (let j = 1; j <= 3; j++) {
    console.log(i + " x " + j + " = " + (i * j));
  }
}
// Saída:
// 1 x 1 = 1
// 1 x 2 = 2
// ... até 3 x 3 = 9

É importante notar que a complexidade aumenta: se o loop externo executa n vezes e o interno m vezes, o total de iterações é n * m. Para conjuntos grandes, isso pode impactar o desempenho.

Também é possível usar break com rótulos para sair de loops aninhados:

externo: for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 3; j++) {
    if (i === 1 && j === 1) {
      break externo; // sai do loop externo
    }
    console.log(i, j);
  }
}
// Saída: 0 0, 0 1, 0 2, 1 0

Boas práticas

Algumas recomendações ao usar o laço for:

  • Declare o contador com let dentro do for para limitar o escopo.
  • Evite modificar o contador dentro do bloco, a menos que seja necessário.
  • Prefira loops for quando o número de iterações for conhecido; caso contrário, considere while.
  • Use nomes de variáveis descritivos (ex.: indice em vez de i quando o contexto exigir clareza).
  • Cuidado com loops infinitos: sempre verifique se a condição pode se tornar falsa.

Referências

Exercícios

  1. Escreva um laço for que imprima os números pares de 2 a 20 (inclusive).

    2. ✓ Resposta: 
    for (let i = 2; i <= 20; i += 2) {
  console.log(i);
}
  2. Crie um laço for que percorra um array de nomes (let nomes = ["Ana", "João", "Maria"]) e imprima cada nome em maiúsculas.

    3. ✓ Resposta: 
    let nomes = ["Ana", "João", "Maria"];
for (let i = 0; i < nomes.length; i++) {
  console.log(nomes[i].toUpperCase());
}
  3. Usando break, crie um laço que imprima números de 1 a 10, mas pare quando chegar no 7.

    4. ✓ Resposta: 
    for (let i = 1; i <= 10; i++) {
  if (i === 7) {
    break;
  }
  console.log(i);
}
// Saída: 1, 2, 3, 4, 5, 6
  4. Usando continue, crie um laço que imprima números de 1 a 10, pulando os múltiplos de 3.

    5. ✓ Resposta: 
    for (let i = 1; i <= 10; i++) {
  if (i % 3 === 0) {
    continue;
  }
  console.log(i);
}
// Saída: 1, 2, 4, 5, 7, 8, 10
  5. Escreva um laço aninhado que imprima uma matriz identidade 3x3 (1 na diagonal principal, 0 nos demais).

    6. ✓ Resposta: 
    for (let i = 0; i < 3; i++) {
  let linha = "";
  for (let j = 0; j < 3; j++) {
    if (i === j) {
      linha += "1 ";
    } else {
      linha += "0 ";
    }
  }
  console.log(linha);
}
// Saída:
// 1 0 0
// 0 1 0
// 0 0 1