Mostrando postagens com marcador Laços. Mostrar todas as postagens
Mostrando postagens com marcador Laços. Mostrar todas as postagens

Como Usar o Laço Foreach em PHP: O Guia Definitivo para Arrays

Laço Foreach em PHP: Como Percorrer Arrays (Passo a Passo) 

Nas aulas anteriores da nossa Apostila de PHP Progressivo, nós desbravamos o universo dos Arrays. Aprendemos a criar listas numéricas, mapear dados com Arrays Associativos e até a gerar listas automáticas com a função range().

Mas existe um "elefante na sala": de que adianta ter um array gigantesco, cheio de dados importantes de um Banco de Dados, se você não sabe como "ler" esses dados um por um de forma automatizada para mostrar na tela do usuário?

Como se já não bastasse o número de laços convencionais (while, do while e for) existentes na linguagem, os criadores do PHP desenvolveram uma estrutura de repetição especialmente criada para varrer Arrays. Prepare-se para conhecer o seu novo melhor amigo na programação web: o laço foreach.

O que é o Laço Foreach em PHP?

O foreach (que em português significa "para cada") é uma estrutura de controle de repetição exclusiva para interagir com arrays e objetos. Diferente do laço for, você não precisa criar um contador numérico (ex: $i = 0) ou saber o tamanho exato do array. O foreach automaticamente percorre a lista do primeiro ao último elemento, parando sozinho quando os dados acabam.

A beleza do foreach é que ele gera um código limpo (Clean Code) e à prova de falhas (bugs de loop infinito). Vamos ver como ele funciona na prática nos dois cenários mais comuns do mercado.

O Laço foreach para Arrays Numéricos (Simples)

Para ler arrays comuns (indexados por números automáticos), a sintaxe é extremamente descritiva: foreach ($array_original as $item_atual). A leitura literal disso é: "Para cada elemento dentro do meu array, trate-o como uma variável chamada $item_atual".

Vamos pegar o seguinte array de carros populares e exibi-los na tela:

<?php
// 1. Nosso array principal (a sacola com os dados)
$carros = ['Gol', 'Celta', 'Fox', 'Corolla', 'Civic'];

// 2. O laço mágico
foreach ($carros as $car) {
    echo "Carro disponível: $car <br>";
}
?>

O que acontece nos bastidores (Raio-X Sênior):

  1. Na primeira "volta" do loop, o PHP vai no array $carros, pega o índice [0] ("Gol") e joga dentro da variável temporária $car. O comando echo imprime "Gol".
  2. Na segunda volta, o PHP pega o índice [1] ("Celta"), joga em $car, e imprime.
  3. Isso se repete automaticamente até o "Civic". Quando o PHP tenta ir para o próximo e percebe que o array acabou, ele encerra o laço com segurança. Fim da dor de cabeça!

Solidifique sua Lógica de Programação

Se você entende como loops funcionam, você constrói qualquer sistema. Pratique exaustivamente com nosso material oficial.

Mega Pack 7 Apostilas de Programação PDF

Conheça nosso Mega Pack de Apostilas PDF e aprenda no seu ritmo, offline e com exercícios baseados no mercado real.

O Loop foreach para Arrays Associativos (Chave => Valor)

Aqui é onde o foreach mostra seu verdadeiro poder. Lembre-se: os Arrays Associativos não são organizados por números lógicos (0, 1, 2), mas sim por palavras-chave definidas por você (ex: 'popular', 'sedan').

Se as chaves são nomes customizados, não há como usar o loop for tradicional para procurá-las. A sintaxe especial do foreach para resgatar tanto a chave quanto o valor é: foreach ($array as $chave => $valor).

Acompanhe este exemplo corporativo de uma concessionária:

<?php
// Definindo nosso array associativo (Key => Value)
$carros = [
    'popular' => 'Celta',
    'sedan'   => 'Corolla',
    'premium' => 'BMW M3',
    'suv'     => 'HR-V'
];

// O PHP extrai a Chave e o Valor a cada volta do loop
foreach ($carros as $categoria => $modelo) {
    echo "Categoria: <strong>$categoria</strong> | Modelo Sugerido: $modelo <br>";
}
?>

A variável $categoria vai capturar as chaves ('popular', 'sedan'...) e a variável $modelo vai armazenar o dado correspondente àquela chave na volta atual. Você tem o controle absoluto sobre as duas informações!

Conteúdo Avançado: Modificando Valores do Array (Por Referência)

Para você se destacar no mercado, vamos ensinar um "pulo do gato". O comportamento padrão do foreach é apenas ler os dados copiando-os para a variável temporária. Se você alterar a variável temporária dentro do loop, o array original continua intacto.

Mas, e se você precisar varrer um array de preços e aplicar 10% de desconto em todos eles? Para que o foreach modifique o array original de verdade, você deve usar o caractere & (E comercial) antes do valor. Isso é chamado de "Passagem por Referência".

<?php
$precos = [100, 200, 300];

// O "E comercial" (&) conecta $valor diretamente ao array original
foreach ($precos as &$valor) {
    $valor = $valor * 2; // Dobra o preço
}
unset($valor); // Boa prática Sênior: quebra a referência ao fim do laço

// O array original agora está modificado permanentemente!
print_r($precos); // [200, 400, 600]
?>

Simulador Interativo: Veja o Foreach em Ação!

Visualize passo a passo como o PHP itera (varre) um array associativo. Clique no botão "Próxima Volta" para entender o fluxo lógico.

⚙️ Raio-X do Foreach (Passo a Passo)

$usuario = ['nome' => 'Ana', 'idade' => 28, 'cargo' => 'Dev'];

foreach ($usuario as $chave => $valor) {
  echo "$chave = $valor";
}
Volta: 0 / 3
Terminal de Saída:
Aguardando execução...

Você quer fazer Listagens de Banco de Dados? 🗄️

O segredo por trás de toda loja virtual, feed do Facebook ou listagem de posts num blog é um laço FOREACH. O sistema busca no MySQL uma matriz de dados, e o foreach gera automaticamente o HTML (divs e imagens) para cada produto. Domine essa integração estudando com a nossa Apostila Premium!

"Sempre tive dificuldade com os laços for e while. Quando peguei a apostila e entendi como integrar o PHP com HTML usando Foreach, eu finalmente consegui criar meu primeiro sistema de Loja Virtual funcional."
- Lucas G., Desenvolvedor Web.
📥 Baixar Apostila e Aprender Integração MySQL

Laços WHILE e DO WHILE em Perl - Como usar

Neste tutorial de Perl, vamos dar início ao estudos das estruturas de repetição, também chamadas de laços ou loopings, começando pelo bom e velho while e depois vamos conhecer o do while.

Laço WHILE em Perl

A sintaxe do laço WHILE é a seguinte:
while( expressão ){
   # código a ser executado
   # caso a expressão seja
   # verdadeira
}
Funciona da seguinte maneira: digitamos while, abrimos parêntesis e dentro deste colocamos alguma expressão. Pode ser um valor (como um número, um booleano como verdadeiro ou falso) ou geralmente uma condição, um teste condicional cujo resultado vai ser verdadeiro ou falso.

Caso a expressão final seja verdadeiro, o código dentro das chaves do laço WHILE é executado.
Ao final de cada execução (chamamos cada rodada de execução de iteração), a expressão é avaliada novamente.

Se ela continuar sendo verdadeira, o código continua a ser rodado e rodado e rodado...
O comum é haver alguma coisa dentro do código que uma hora vá mudar o teste condicional que está sendo realizado, para ele virar falso em algum momento e parar a execução do while.

Exemplos de laços WHILE em Perl

Primeiro, vamos aprender a contar de 1 até 100 com o laço WHILE.
Vamos usar a variável $num para armazenar números de 1 até 100, e printar eles na tela.

O código fica assim:
#!/usr/bin/perl

$num=1;

while($num <= 100){
        print $num, "\n";
        $num++;
}    

Primeiro, inicializamos a variável com o valor 1.
O teste que iremos fazer é: $num<=100
Em outras palavras: a variável é menor ou igual a 100? Se sim, rode o código abaixo...

No código dentro da estrutura de repetição, printamos a variável.
Em seguida, temos que incrementar ela em uma unidade, fazemos isso com o operador: ++

Agora, o valor de $num é 2. A expressão do while é avaliada novamente, e ela vai dar verdadeiro de novo. O código vai executar, printar, e incrementar...e isso vai acontecendo até $num ter o valor 100.

Nesse valor, o teste ainda é verdadeiro, o print é realizado e quando a variável é incrementada, passa a valer 101. Então, no próximo teste da expressão da while, o resultado vai ser falso e o looping é encerrado.

Vamos fazer agora o contrário, uma contagem regressiva, exibir de 1000 até 1:
#!/usr/bin/perl

$num=1000;

while($num>0){
        print $num, "\n";
        $num--;
}    

Note que inicializamos agora com o valor 1000, o teste é "enquanto ela for maior que 0" e decrementamos a variável ($num--).

Rapidinho fez essa conta, não foi? Poderoso, esse Perl, não é?

O looping DO WHILE em Perl

O laço WHILE tem uma característica especial: ele só roda a primeira iteração se a expressão contida nele for VERDADEIRA, se for FALSA, o laço nem começa.

Se você quiser que pelo menos uma iteração ocorra, que o teste seja executado pelo menos uma vez, recomendamos usar o DO WHILE. A estrutura dele é bem parecida com o while:
do{
   # código a ser
   # executado
}while(condição);   

Primeiro ele faz a iteração (DO), só depois é que testa a condição.
Se ela for verdadeira, executa de novo o código entre as chaves.

Uma grande utilidade do laço DO WHILE é exibir menus.
Os menus devem ser exibidos ao menos uma vez pro usuário, se ele quiser sair do programa logo de cara, ok, mas ele deve ser exibido pelo menos uma vez.

Vamos ver um exemplo de uma aplicação bancária:
#!/usr/bin/perl

do{
        print "Escolha uma opação:\n";
        print "0. Sair\n";
        print "1. Extrato\n";
        print "2. Saque\n";
        print "3. Transferência\n\n";
        chomp($op = <STDIN>);
}while($op != 0);
Armazenamos a opção do usuário na variável $op.
Se ele digitar 1, 2 ou 3, deve ocorrer alguma coisa específica (chamar as opções de transferência, ir pra tela de saque etc), depois veremos como incrementar isso em Perl.

Depois, o menu é exibido novamente.
E ele só para de ser exibido se você digitar 0, para sair.
Veja o teste: $op != 0
Isso quer dizer: rodar esse looping, enquanto a opção for diferente de 0.

O código a seguir pede a senha para o usuário.
Se for correta, cai no IF e avisamos que está entrando no sistema.
Se for errada, cai no ELSE e avisamos para ele tentar novamente:
#!/usr/bin/perl

do{
        print "Digite a senha:\n";
        chomp($password = <STDIN>);

        if($password eq 'rush2112'){
                print "Entrando no sistema...\n";
        }else{
                print "Senha errada, tente novamente.\n\n";
        }
}while($password ne 'rush2112');
Note que a condição é: enquanto a senha não for igual a "rush2112".
Ou seja, a senha é rush2112, se ele não digitar a senha correta, vai ficar preso eternamente nessa tela pedindo senha...a única maneira de entrar no sistema portanto, é digitando a senha correta.

Veja que colocamos um teste condicional IF ELSE dentro de uma estrutura de controle DO WHILE, isso é bastante comum na programação, os testes, laços e loopings serem 'aninhados' a outras estruturas de controle de fluxo.

Vamos ver agora como imprimir de 1 até 100 com o DO WHILE:
#!/usr/bin/perl

$num=1;

do{
        print $num, "\n";
        
}while(++$num<=100);
Note o comando: ++$num <=100
Isso quer dizer que primeiro a variável $num é incrementada (pois o símbolo ++ veio antes) e só depois que ela é usada para o teste condicional.

Agora faça: $num++ <= 100
O que acontece com o resultado? Por quê?
Explique nos comentários.

Operadores de Comparação em Perl

Agora que já estudamos os conceitos básicos de Perl, vamos aprender coisas mais complexas que deixarão nossos scripts cada mais interessantes e fazendo coisas úteis.

Vamos aprender como comparar números e strings, em Perl.

Operadores de Comparação Numérica em Perl

Existem 6 operadores de comparação, que podemos usar com números, em Perl, e são bem simples, pois se assemelham aos que usamos na matemática.

Os operadores são:

  1. Igualdade: ==
  2. Desigualdade: !=
  3. Maior: >
  4. Menor: <
  5. Maior igual: >=
  6. Menor igual: <=

Usamos eles assim:
  • valor1 operador valor2
E essa operação sempre retorna verdadeiro (TRUE ou 1) ou falso (FALSE ou 0).
Por exemplo, rode o seguinte script:
#!/usr/bin/perl

print "2==2: ",2==2,"\n";
Ele vai retornar: 1
O que o print faz é o resultado da operação 2 == 2
Essa operação é uma operação de comparação, você tá perguntando: 2 é igual a 2 ?
Ele responde com verdade (representado por 1).

Agora teste esta:

#!/usr/bin/perl

print "2==2: ",2==2,"\n";
print "1>2 : ",1>2,"\n";

O resultado é:

2==2: 1
1>2 : 

Quando perguntamos se 1 é maior que 2, ele responde com vazio, nada, nulo...que é o mesmo que falso em Perl.

E se perguntarmos se 1 é diferente de 2?
Fazemos isso com: 1 != 2, e é uma afirmação verdadeira, teste o script:
#!/usr/bin/perl

print "2==2: ",2==2,"\n";
print "1>2 : ",1>2,"\n";
print "1!=2: ",1!=2,"\n";
Deu tudo certo?

A operação: $a < $b
Retorna verdadeiro (1) se $a for menor que $b, e falso se $a for maior, ou até igual, a $b.

Já a expressão:
$a >= $b
Retorna verdadeiro (1), se $a for maior ou se for igual a $b, e retorna falso (vazio), se $a for menor que $b.

Por fim, a operação:
$a <= $b
Retorna 1 se $a for menor ou se $a for igual a b. Se $a for maior que $b ela retorna falso (vazio).

Comparações com strings em Perl

Para compararmos strings, usaremos umas letrinhas, que representam a mesma coisa dos operadores acima:
  1. Igualdade: eq 
  2. Desigualdade: ne
  3. Maior que: gt
  4. Menor que: lt
  5. Maior igual: ge
  6. Menor igual: le
Ou seja, os operadores de comparação de strings em Perl são:
eq (equal), ne (not equal), gt (greater than), lt (less than), ge (greater than or equal to) e le (less than or equal to).

A comparação é feita caractere por caractere, um por um, comparando para saber se as strings são iguais ou não.

Vamos ver alguns exemplos:
#!/usr/bin/perl

print "rush eq rush: ", 'rush' eq 'rush',"\n";
print "rush ne Rush: ",'rush' ne 'Rush',"\n";
print "abc gt ab   : ",'abc' gt 'ab',"\n";
print "bc lt bcd   : ",'bc' lt 'bcd',"\n";
Note que no padrão ASCII, as letras maiúsculas vem antes das minúsculas:
#!/usr/bin/perl

print "A lt a: ", 'A' lt 'a',"\n";
print "b gt B: ",'B' ne 'b',"\n";
Ou seja, 'A' é menor que 'a'
E 'b' é maior que 'B'

Teste os scripts, pessoal. Vejam os resultados.
Todas essas operações são como 'perguntas' para o Perl, que responde com 1 ou vazio, ou seja, verdadeiro ou falso.

E cuidado pra não confundir:
$a == 1 : é uma comparação, é uma pergunta '$a é igual a 1?', gera um retorno verdadeiro ou falso

E:
$a = 1 : é uma atribuição, $a vai receber o valor 1 e ponto final, acabou aí.