Nu je PHP hebt geïnstalleerd en je eerste script werkt, is het tijd voor de bouwstenen van elk programma: variabelen, types en control flow in PHP. Deze drie concepten vormen de basis van alles wat je in PHP gaat schrijven, van een simpel contactformulier tot een volledige WordPress-plugin.
In dit artikel leer je hoe PHP met data omgaat, welke datatypes er bestaan en hoe je met if-statements, loops en de moderne match-expressie de flow van je script stuurt. We sluiten af met praktische voorbeelden die je direct kunt gebruiken.
Nog geen PHP op je systeem? Begin dan eerst met onze gids PHP installatie en eerste script: stap voor stap.
Variabelen in PHP: de basis
Een variabele is een naam waaraan je een waarde koppelt. In PHP herken je variabelen aan het dollarteken ($) dat ervoor staat.
<?php
$naam = "Sander";
$leeftijd = 34;
$isDeveloper = true;
echo "Hallo $naam, je bent $leeftijd jaar oud.";
Belangrijke regels voor variabelen in PHP:
- Een variabele begint altijd met
$, gevolgd door een letter of underscore. - Je kunt cijfers gebruiken, maar niet als eerste teken na het dollarteken.
- PHP is hoofdlettergevoelig:
$naamen$Naamzijn verschillende variabelen. - Je hoeft het type niet op te geven: PHP bepaalt dat zelf.
Variabele scope
Variabelen hebben een bereik (scope). Een variabele die je binnen een functie maakt, is buiten die functie niet beschikbaar. Andersom geldt hetzelfde: een globale variabele is niet automatisch toegankelijk binnen een functie.
<?php
$boodschap = "Hallo wereld";
function begroet() {
// $boodschap is hier niet beschikbaar
echo $boodschap ?? "Geen boodschap gevonden";
}
begroet(); // Output: Geen boodschap gevonden
Gebruik daarom liever functieparameters om data door te geven in plaats van het global keyword, dat als een anti-pattern wordt beschouwd in moderne PHP.
Datatypes in PHP
PHP kent een aantal primitieve en samengestelde datatypes. Als je begrijpt hoe deze zich gedragen, voorkom je veel typische beginnersfouten.
Scalaire types
De vier scalaire types zijn de meest voorkomende:
- string: tekst, bijvoorbeeld
"Hallo"of'PHP'. - int (integer): hele getallen, zoals
42of-7. - float: decimale getallen, zoals
3.14of2.0. - bool (boolean):
trueoffalse.
<?php
$titel = "PHP voor beginners"; // string
$aantalLezers = 1200; // int
$gemiddeldeScore = 4.8; // float
$isGepubliceerd = true; // bool
Samengestelde types
Naast scalaire types zijn er samengestelde types:
- array: een verzameling waarden, geïndexeerd of associatief.
- object: een instantie van een class.
- null: een speciaal type dat "geen waarde" aanduidt.
<?php
$kleuren = ["rood", "groen", "blauw"]; // indexed array
$gebruiker = [
"naam" => "Eva",
"email" => "[email protected]",
]; // associative array
$geenWaarde = null;
Type juggling en strict types
PHP is dynamisch getypeerd: je kunt een variabele van type laten veranderen door er een andere waarde in te zetten. PHP converteert ook automatisch tussen types, iets dat bekendstaat als type juggling.
<?php
$getal = "5" + 3; // resultaat: 8 (int)
$tekst = "5" . 3; // resultaat: "53" (string)
Dit kan handig zijn, maar leidt ook tot subtiele bugs. Sinds PHP 7 kun je met declare(strict_types=1); bovenaan je bestand strikte typering afdwingen voor functieparameters en return-types.
<?php
declare(strict_types=1);
function optellen(int $a, int $b): int {
return $a + $b;
}
optellen(2, 3); // werkt
optellen("2", "3"); // TypeError
De officiële PHP-documentatie over types geeft een volledig overzicht van alle datatypes en hun gedrag.
Constanten: variabelen die niet veranderen
Naast variabelen kent PHP ook constanten. Die stel je één keer in en daarna zijn ze onveranderlijk.
<?php
define("SITE_NAAM", "We Develop Communication");
const MAX_UPLOADS = 10;
echo SITE_NAAM; // Output: We Develop Communication
Constanten worden conventioneel in hoofdletters geschreven en hebben geen dollarteken. Gebruik ze voor waarden die door je hele applicatie hetzelfde blijven, zoals API-endpoints of configuratie-opties.
Control flow: de richting van je script
Control flow bepaalt welke code wordt uitgevoerd en in welke volgorde. Zonder control flow zou elk script simpelweg regel voor regel worden afgewerkt zonder enige logica.
If, elseif en else
Het meest basale control-flow-statement is if. Je voert code uit als een conditie waar is.
<?php
$leeftijd = 18;
if ($leeftijd >= 18) {
echo "Je mag stemmen.";
} elseif ($leeftijd >= 16) {
echo "Je mag alvast oefenen met provinciale verkiezingen.";
} else {
echo "Nog even geduld.";
}
Vergelijkingsoperatoren
PHP heeft twee soorten gelijkheid die je goed uit elkaar moet houden:
==, loose comparison: vergelijkt waarden en converteert types indien nodig.===, strict comparison: vergelijkt waarde én type.
<?php
var_dump(0 == "hallo"); // false sinds PHP 8.0
var_dump("1" == 1); // true
var_dump("1" === 1); // false
Gebruik standaard ===. Dat voorkomt verrassingen door type juggling en maakt je code voorspelbaarder.
De ternary en null coalescing operator
Voor korte condities zijn er handige verkorte schrijfwijzen:
<?php
// Ternary
$label = $isActief ? "Actief" : "Inactief";
// Null coalescing (sinds PHP 7.0)
$gebruikersnaam = $_GET["user"] ?? "gast";
// Null coalescing assignment (sinds PHP 7.4)
$config["timeout"] ??= 30;
De null coalescing operator (??) is vooral handig als je werkt met mogelijk ontbrekende array-keys of null-waarden zonder een isset()-check.
Match: het moderne alternatief voor switch
Sinds PHP 8.0 is er de match-expressie. Die is korter dan switch, gebruikt strikte vergelijking en geeft direct een waarde terug.
<?php
$status = "published";
$label = match ($status) {
"draft" => "Concept",
"published" => "Gepubliceerd",
"archived" => "Gearchiveerd",
default => "Onbekend",
};
Gebruik match wanneer je een waarde wilt toekennen op basis van één variabele. Voor complexere logica met meerdere statements per case is switch nog steeds bruikbaar.
Loops: herhalen van code
Loops voer je uit om dezelfde code meerdere keren te draaien, bijvoorbeeld om door een array heen te lopen.
For en while
<?php
// For loop
for ($i = 1; $i <= 5; $i++) {
echo "Ronde $i\n";
}
// While loop
$teller = 0;
while ($teller < 3) {
echo "Teller: $teller\n";
$teller++;
}
Foreach: ideaal voor arrays
Voor arrays is foreach de meest natuurlijke loop:
<?php
$talen = ["PHP", "JavaScript", "Python"];
foreach ($talen as $taal) {
echo "$taal is een programmeertaal.\n";
}
$gebruiker = ["naam" => "Eva", "rol" => "admin"];
foreach ($gebruiker as $sleutel => $waarde) {
echo "$sleutel: $waarde\n";
}
Break en continue
Met break stop je een loop volledig, met continue sla je de huidige iteratie over.
<?php
foreach (range(1, 10) as $getal) {
if ($getal % 2 === 0) {
continue; // sla even getallen over
}
if ($getal > 7) {
break; // stop na 7
}
echo $getal . "\n"; // output: 1, 3, 5, 7
}
Een praktisch voorbeeld: formuliervalidatie
Laten we alles combineren in een mini-voorbeeld dat input valideert:
<?php
declare(strict_types=1);
function valideerEmail(?string $email): string {
if ($email === null || $email === "") {
return "E-mail is verplicht.";
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
return "Ongeldig e-mailadres.";
}
return "OK";
}
$testCases = ["[email protected]", "niet-geldig", "", null];
foreach ($testCases as $input) {
$resultaat = valideerEmail($input);
echo "Input: " . ($input ?? "null") . " → $resultaat\n";
}
Dit voorbeeld gebruikt strikte types, een nullable parameter, een if-check, een return-waarde én een foreach-loop. Precies de combinatie die je in echte PHP-projecten constant tegenkomt.
Wil je meer weten over waarom PHP deze fundering zo stevig heeft gemaakt? Lees dan Wat is PHP en waarom bestaat het nog steeds? voor de bredere context.
Veelgemaakte fouten bij beginners
Let op deze valkuilen wanneer je begint met variabelen en control flow:
- Vergeten van het dollarteken:
naam = "Sander"geeft een parse error. =met==verwarren:if ($x = 5)is een toekenning, geen vergelijking.- Te veel
globalgebruiken: geef waarden door via functieparameters. - Losse vergelijkingen vertrouwen: gebruik
===waar mogelijk. - Oneindige loops: vergeet niet je tellervariabele te verhogen in een
while-loop.
Voor een volledige referentie van alle control-flow-structuren raden we de PHP control structures documentatie aan.
Veelgestelde vragen
Wat is een variabele in PHP?
Een variabele in PHP is een naam waaraan je een waarde koppelt, zodat je die later in je script kunt hergebruiken. Variabelen beginnen altijd met een dollarteken, bijvoorbeeld $naam = 'Sander'.
Is PHP een dynamisch of statisch getypeerde taal?
PHP is dynamisch getypeerd. Dat betekent dat je het type van een variabele niet hoeft op te geven: PHP bepaalt het type op basis van de waarde die je toekent. Sinds PHP 7 kun je wel optioneel type declarations gebruiken om functies strikter te maken.
Wat is het verschil tussen == en === in PHP?
== vergelijkt alleen de waarde en converteert zo nodig het type (loose comparison). === vergelijkt zowel waarde als type (strict comparison). Gebruik === als standaard om onverwachte conversies te voorkomen.
Wanneer gebruik je een match-expressie in plaats van switch?
Match (sinds PHP 8.0) is korter, gebruikt strikte vergelijking en geeft een waarde terug. Gebruik match wanneer je een waarde wilt toekennen op basis van condities; switch past beter bij blokken met meerdere statements per case.
Wat is type juggling in PHP?
Type juggling is het automatisch omzetten van waarden tussen types, bijvoorbeeld een string '5' naar een integer 5 bij een rekensom. Handig, maar het kan tot bugs leiden; activeer daarom strict_types waar mogelijk.
Volgende stap
Je beheerst nu de kern: variabelen opslaan, types onderscheiden en de flow van je script sturen met if-statements, loops en match. In het volgende deel van deze serie duiken we in functies, return-types en namespaces, de manier waarop je herbruikbare logica opbouwt in PHP.
Houd de blog in de gaten en oefen in de tussentijd met kleine scriptjes. Juist door te typen, fouten te maken en te debuggen blijft de kennis hangen.