PHP-lessen - les 12 - Lussen while, foreach, for

In de programmeerwereld, en zelfs in het dagelijks leven, moeten we vaak herhaalde handelingen uitvoeren totdat we het gewenste resultaat bereiken. In het dagelijks leven noemen we dit soms een “kwelling”, maar in programmeren noemen we het lussen (loops). Lussen komen vaak voor in PHP, omdat ze een handige manier zijn om arrays te doorlopen, berekeningen uit te voeren, en nog veel meer. Laten we beginnen met de eenvoudigste en populairste lus: while.

PHP while-lussen

De while-lus is erg eenvoudig: tussen ronde haakjes schrijven we de voorwaarde, en tussen accolades zetten we de acties die moeten worden uitgevoerd zolang de voorwaarde waar is. Een voorwaarde is een logische expressie die slechts twee toestanden kan aannemen: TRUE of FALSE. Als je nog niet goed begrijpt wat logische expressies zijn, lees dan de les over de if-operator nog eens door. Hier is een eenvoudig voorbeeld van een while-lus:

<?php
$counter = 5;
$newArray = array();
while($counter > 2){
  $newArray[] = $counter;
  $counter--;
}
print_r($newArray);
?>

Het resultaat is een array met de elementen 5, 4, 3. Laten we stap voor stap bekijken wat er gebeurt:

1e stap: $counter = 5 (5 > 2) — de voorwaarde is waar, dus het blok wordt uitgevoerd.
2e stap: $counter = 4 (4 > 2) — nog steeds waar.
3e stap: $counter = 3 (3 > 2) — nog steeds waar.
4e stap: $counter = 2 (2 = 2) — de voorwaarde is niet langer waar, dus de lus stopt. Het getal 2 komt niet meer in de array.

Laten we een ander voorbeeld bekijken — de tabellering van de functie y(x) = 2x - 1:

<?php
// functie y(x) = 2x -1;
$x = -10;
while($x <= 10){
  $y = 2*$x - 1;
  print 'y(' . $x . ') = ' . $y . '<br />';
  $x++;
}
?>

Als resultaat worden de functiewaarden voor x in het interval [-10, 10] onder elkaar weergegeven.

Hier zie je een blokdiagram van de while-lus. Het toont de algemene werking van de lus: er is een voorwaarde en een codeblok (het “lichaam” van de lus). Zolang de voorwaarde waar is, voert PHP het lichaam uit; zodra de voorwaarde niet meer waar is, gaat het programma verder met de rest van de code.

Een belangrijke opmerking: als je de regel $x++; verwijdert, zal de waarde van $x nooit veranderen, en de voorwaarde zal dus altijd waar blijven. Wat gebeurt er dan?

<?php
// functie y(x) = 2x -1;
$x = -10;
while($x <= 10){
  $y = 2*$x - 1;
  print 'y(' . $x . ') = ' . $y . '<br />';
  // $x++;
}
?>

Dan krijg je een ramp: de code blijft oneindig draaien. Dit noemen we een oneindige lus. Vermijd dit soort situaties, want een oneindige lus kan ervoor zorgen dat je website volledig vastloopt!

PHP foreach-lussen

Een andere zeer nuttige lus is foreach. Deze wordt vaak gebruikt om door arrays te lopen. Daarmee bedoelen we: één voor één de elementen van een array ophalen, een actie uitvoeren, en doorgaan naar het volgende element, totdat alle elementen zijn doorlopen.

Laten we dit illustreren met een voorbeeld. Stel, we hebben tien elementen met de waarden “rood” en “blauw”. We willen het aantal rode elementen tellen:

<?php
$counter = 0;
$newArray = array(
  1 => 'rood',
  2 => 'blauw',
  3 => 'blauw',
  4 => 'rood',
  5 => 'rood',
  6 => 'blauw',
  7 => 'rood',
  8 => 'blauw',
  9 => 'rood',
  10 => 'blauw',
);
foreach($newArray as $value){
  if($value == 'rood'){
    $counter++;
  }
}
print 'We hebben ' . $counter . ' rode elementen.';
?>

Zoals je ziet, is dit vrij eenvoudig. De operator as wordt hier gebruikt om elk element van de array één voor één te verwerken. Zodra alle elementen zijn doorlopen, stopt de foreach-lus automatisch.

Maar soms bevatten arrays ook geneste arrays. In dat geval kun je een geneste foreach-lus gebruiken om elk subelement apart te doorlopen:

<?php
$counter = 0;
$newArray = array(
  1 => array(
    1 => 'rood',
    2 => 'blauw',
    3 => 'blauw',
  ),
  2 => array(
    1 => 'rood',
    2 => 'rood',
    3 => 'blauw',
  )
);
foreach($newArray as $subArray){
  foreach($subArray as $element){
    if($element == 'rood'){
      $counter++;
    }
  }
}
print 'We hebben ' . $counter . ' rode elementen.';
?>

Hopelijk is het principe van foreach nu duidelijk. We zullen deze lus nog vaak tegenkomen in verdere voorbeelden.

De for-lus

De for-lus lijkt op de while-lus. We gebruiken for meestal wanneer we van tevoren weten hoe vaak de lus moet worden uitgevoerd — bijvoorbeeld 10 of 100 keer:

for($i = 0; $i < 10; $i++){
  // tien herhalingen
}

Laten we analyseren waaruit de for-lus bestaat.

for(){

}

Net als bij andere lussen worden de parameters tussen ronde haakjes geplaatst. Gewoonlijk gebruiken we drie onderdelen:

1. $i = 0 — initialisatie van de teller (beginwaarde).
2. $i < 10 — de voorwaarde waaronder de lus actief blijft.
3. $i++ — verhoging van de teller bij elke herhaling.