Como percorrer um vetor

Percorrer é visitar cada elemento segundo uma ordem

Depois de aprender como vetores e arrays organizam valores, o próximo passo é aplicar a mesma ação a todas as posições. Percorrer um vetor significa visitar seus elementos segundo uma ordem definida, normalmente do primeiro ao último, sem pular uma posição nem acessar uma posição inexistente.

Considere as leituras:

temperaturas = [18, 21, 23, 20, 19]

Escrever cinco comandos separados funcionaria apenas para esse tamanho:

EXIBIR temperaturas[0]
EXIBIR temperaturas[1]
EXIBIR temperaturas[2]
EXIBIR temperaturas[3]
EXIBIR temperaturas[4]

Um percurso substitui essa repetição manual por uma regra que acompanha o tamanho real da coleção. Para uma coleção indexada a partir de zero, o contrato é:

0 <= indice < tamanho

Enquanto essa condição for verdadeira, indice aponta para uma posição válida. Quando indice alcança tamanho, o percurso termina antes do acesso.

Construa o percurso com quatro decisões

Um percurso crescente precisa responder quatro perguntas:

1. onde começa? No índice 0;
2. enquanto pode continuar? Enquanto indice < tamanho;
3. o que faz em cada posição? Lê ou processa vetor[indice];
4. como avança? Soma 1 ao índice.

Em pseudocódigo:

PARA indice <- 0; indice < tamanho(temperaturas); indice <- indice + 1 FAÇA
  EXIBIR temperaturas[indice]
FIM PARA

Esse padrão é uma aplicação direta do laço for. O tamanho não é o último índice: ele é o primeiro valor que já está fora da coleção. Por isso a condição usa <, e não <=.

Acompanhe índice e valor em cada passagem

Rastrear a execução evita que o laço pareça um bloco indivisível. Para temperaturas = [18, 21, 23, 20, 19], cada teste verdadeiro libera exatamente um acesso:

Teste	indice	indice < 5	Elemento acessado	Valor exibido
1	0	verdadeiro	temperaturas[0]	18
2	1	verdadeiro	temperaturas[1]	21
3	2	verdadeiro	temperaturas[2]	23
4	3	verdadeiro	temperaturas[3]	20
5	4	verdadeiro	temperaturas[4]	19
6	5	falso	nenhum	—

O percurso executa cinco corpos, cinco incrementos e seis testes. O teste extra não é um erro: ele confirma que não há outra posição válida. Você pode reproduzir essa tabela com a técnica de teste manual de algoritmos.

Implemente o mesmo contrato em JavaScript

const temperaturas = [18, 21, 23, 20, 19];

for (let indice = 0; indice < temperaturas.length; indice += 1) {
  console.log(`Posição ${indice}: ${temperaturas[indice]} °C`);
}

As três partes do cabeçalho correspondem ao contrato:

• let indice = 0 seleciona a primeira posição;
• indice < temperaturas.length protege o acesso;
• indice += 1 produz a próxima posição.

Evite copiar o tamanho para um número fixo como indice < 5. Se a coleção mudar para três ou oito elementos, o laço deixaria de representar seus dados. Consultar length mantém limite e coleção ligados.

Também é possível escrever o percurso com while:

let indice = 0;

while (indice < temperaturas.length) {
  console.log(temperaturas[indice]);
  indice += 1;
}

O resultado é o mesmo. Para uma progressão por índice, o for costuma deixar inicialização, condição e avanço mais próximos e fáceis de revisar. O while pode ser preferível quando o avanço depende de eventos ou regras menos regulares.

Use o índice apenas quando a posição importa

Nem toda visita precisa expor uma posição. Se o objetivo é somente ler cada valor, a iteração direta comunica melhor a intenção.

JavaScript com for...of

for (const temperatura of temperaturas) {
  console.log(`${temperatura} °C`);
}

C# com foreach

int[] temperaturas = [18, 21, 23, 20, 19];

foreach (int temperatura in temperaturas)
{
    Console.WriteLine($"{temperatura} °C");
}

Python com for

temperaturas = [18, 21, 23, 20, 19]

for temperatura in temperaturas:
    print(f"{temperatura} °C")

Escolha pelo dado que o corpo realmente utiliza:

O corpo precisa de...	Forma mais direta
somente o valor atual	iteração por valor
posição e valor	índice ou recurso que forneça ambos
substituir a posição atual	índice, conforme o contrato da linguagem
comparar posições vizinhas	índice com limites adicionais
apenas uma progressão numérica	for com contador, sem fingir que há uma coleção

Em Python, enumerate(temperaturas) entrega posição e valor sem exigir range(len(...)):

for indice, temperatura in enumerate(temperaturas):
    print(indice, temperatura)

Usar uma forma de alto nível não elimina o percurso; apenas entrega ao mecanismo da linguagem o controle da próxima posição. Isso reduz aritmética manual quando o índice não faz parte do problema.

Inverta início, limite e passo para voltar pelo vetor

Percorrer em ordem inversa exige alterar as três partes da progressão. O primeiro índice passa a ser tamanho - 1, a condição inclui 0 e o passo diminui uma unidade:

PARA indice <- tamanho(temperaturas) - 1; indice >= 0; indice <- indice - 1 FAÇA
  EXIBIR temperaturas[indice]
FIM PARA

Em JavaScript:

for (let indice = temperaturas.length - 1; indice >= 0; indice -= 1) {
  console.log(temperaturas[indice]);
}

Para uma coleção vazia, length - 1 resulta em -1; a condição -1 >= 0 já começa falsa. O corpo não executa, que é o comportamento correto para um percurso completo sem elementos.

Atualize elementos sem perder o limite

Quando a posição precisa ser substituída, o índice identifica onde gravar. O exemplo converte temperaturas inteiras de Celsius para uma aproximação em Fahrenheit:

const temperaturas = [18, 21, 23, 20, 19];

for (let indice = 0; indice < temperaturas.length; indice += 1) {
  temperaturas[indice] = Math.round(temperaturas[indice] * 1.8 + 32);
}

console.log(temperaturas); // [64, 70, 73, 68, 66]

O tamanho permanece estável; somente o valor de cada posição muda. Adicionar ou remover elementos durante o mesmo percurso altera índices e limites enquanto eles estão sendo usados. Uma remoção pode deslocar o próximo elemento para uma posição já visitada; uma inserção pode prolongar o laço ou fazer um item ser processado mais de uma vez.

Para esta etapa da trilha, mantenha a estrutura da coleção estável durante o percurso. Se precisar selecionar elementos, monte outra coleção ou use uma operação própria da linguagem cujo contrato seja conhecido.

Diagnostique erros pelos quatro componentes

Quando o percurso falhar, confira início, condição, acesso e avanço.

Usar <= tamanho

for (let indice = 0; indice <= temperaturas.length; indice += 1) {
  console.log(temperaturas[indice]);
}

O laço tenta acessar temperaturas[length], uma posição depois do fim. Corrija para indice < temperaturas.length.

Começar em 1

Se os índices começam em zero, iniciar em 1 pula o primeiro elemento. Começar em um produz sentido apenas quando o problema define outro intervalo ou quando a coleção realmente segue outro contrato.

Esquecer o avanço

Sem indice += 1, a condição continua observando o mesmo estado e o laço pode repetir para sempre. Relacione esse diagnóstico às condições de parada e aos laços infinitos.

Avançar duas vezes

Incrementar no cabeçalho e novamente no corpo pula posições alternadas. Escolha um único lugar para produzir o próximo índice.

Usar um limite independente da coleção

Um número fixo pode funcionar com os dados de hoje e falhar silenciosamente quando o tamanho mudar. Faça a condição depender da própria coleção.

Teste fronteiras antes de confiar no percurso

Três casos pequenos revelam a maior parte dos erros:

Caso	Coleção	Visitas esperadas
vazia	[]	0
unitária	[18]	1, no índice 0
vários elementos	[18, 21, 23]	3, nos índices 0, 1 e 2

Registre também a ordem observada. Um laço que visita três vezes não está correto se visita 0, 2, 1 quando a promessa era ordem crescente. Se o corpo altera valores, confirme o estado final sem confundir quantidade de visitas com resultado da transformação.

Pratique com um relatório de leituras

Use a coleção:

leituras = [12, 15, 14, 18, 17, 13]

Construa um algoritmo que:

1. percorra da primeira à última posição;
2. exiba índice e valor em cada passagem;
3. produza exatamente seis linhas;
4. depois percorra em ordem inversa sem alterar a coleção;
5. teste também [] e [12];
6. reescreva a primeira versão por valor e explique qual informação deixa de ficar disponível diretamente.

O exercício está completo quando você consegue prever a sequência de índices antes de executar e justificar os quatro componentes do laço.

O que você deve guardar

Percorrer um vetor é aplicar uma ação a seus elementos dentro de um limite válido. No percurso crescente mais comum, comece em 0, continue enquanto indice < tamanho, acesse vetor[indice] e avance uma unidade. Essa condição também trata corretamente uma coleção vazia.

Use iteração direta por valor quando a posição não for necessária e use índice quando a posição fizer parte da regra, como uma atualização ou comparação entre vizinhos. Para inverter o sentido, ajuste início, condição e passo em conjunto. Com o percurso seguro dominado, a próxima etapa é usar cada visita para construir operações de busca e agregação em vetores.

Referências

• MDN Web Docs — for. Acesso em 22 set. 2026.
• MDN Web Docs — for...of. Acesso em 22 set. 2026.
• Microsoft Learn — Iteration statements in C#. Acesso em 22 set. 2026.
• Microsoft Learn — for, foreach, do e while. Acesso em 22 set. 2026.
• Python 3 Documentation — for statements. Acesso em 22 set. 2026.
• Python 3 Documentation — enumerate. Acesso em 22 set. 2026.