Wat is PHP? Een tutorial van STRATO

PHP-tutorial voor beginners

PHP is een servergebaseerde open-source scripttaal die voornamelijk dient voor het maken van dynamische webpagina's. Oorspronkelijk stond de afkorting voor ‘Personal Home Page Tools’, maar tegenwoordig voor ‘PHP: Hypertext Preprocessor’.

Terwijl client-side talen zoals HTML, CSS of JavaScript pas in de webbrowser draaien als een website is geladen, draait PHP-code al direct op de webserver. Daar genereren PHP-scripts HTML-pagina’s, die de server vervolgens naar de webbrowser stuurt. De browser krijgt dus niet de werkelijke code (het PHP-script), maar alleen het resultaat van het script.

De centrale toepassing van PHP is serverprogrammering. De focus ligt op dynamische websites en apps. Andere toepassingsgebieden zijn het schrijven van desktoptoepassingen en command-line-programming. PHP biedt, ondanks zijn beginnersvriendelijke syntaxis, een indrukwekkend scala aan functies. De scripttaal heeft een brede databaseondersteuning, draait op diverse platformen en valt onder een speciale PHP-licentie. Daarmee mag je de broncode gratis gebruiken en wijzigen. Het is een overtuigende combinatie van eigenschappen.

WordPress, TYPO3, Joomla en Drupal zijn vier populaire contentmanagementsystemen die gebaseerd zijn op PHP. Volgens een marktanalyse van W3Tech is 79 procent van alle webpagina's op internet inmiddels in PHP geschreven (stand: januari 2021). Daarmee is PHP veruit de populairste servergebaseerde programmeertaal voor webtoepassingen. Reden genoeg om je te verdiepen in de vele mogelijkheden van PHP: Hypertext Preprocessor.

Deze PHP-tutorial voor beginners is bedoeld als eerste kennismaking met de PHP programmeertaal en biedt vooral inzicht in het servergebaseerde PHP programmeren. Voor sommige voorbeelden moet je echter de basisbeginselen van webontwikkeling kennen en kennis van HTML hebben.

De snelste manier om PHP te leren is door de voorbeelden in dit artikel op je eigen computer te proberen en ze aan te passen aan de behoeften van je webproject. Het enige wat je nodig hebt voor programmering met PHP is een webserver met een PHP-interpreter, een tekst-editor (bijv. Notepad++ of Vim) en je webbrowser. Als server adviseren wij de lokale testomgeving XAMPP, die door Apache Friends gratis ter beschikking wordt gesteld voor de besturingssystemen Windows, Linux en macOS.

PHP installeren

Om PHP-scripts te kunnen uitvoeren, heb je een webserver nodig die de scripttaal kan interpreteren. Hiervoor moet je een zogenaamde PHP-interpreter installeren. Dit is software die de PHP-code in een bestand kan herkennen. In principe ondersteunen alle gangbare webservers PHP. De interpreter is inbegrepen in het PHP-downloadpakket. Je kunt de huidige versie gratis downloaden op de officiële website PHP.net.

De installatie van de PHP-interpreter gaat meestal via een servermodule of als FastCGI, maar deze laatste optie raden we om prestatieredenen af. In de praktijk wordt PHP vaak gebruikt in combinatie met de Apache HTTP Server. Als je hierbij een van de databasesystemen MySQL of MariaDB gebruikt, afhankelijk van het besturingssysteem, spreken we over LAMP (Linux), WAMP (Windows) of MAMP (macOS).

Dit soort webstacks zijn als voorgeconfigureerde softwarebundels verkrijgbaar. Om PHP te leren, raden we je het complete pakket XAMPP aan. Dit omvat een lokale installatie van de Apache-webserver inclusief het MariaDB-databasesysteem en de scripttalen Perl en PHP.

PHP-basisprincipes: syntaxis

Heb je een lokale webserver ingesteld (bijvoorbeeld met XAMPP)? Test dan of PHP correct is geïnstalleerd en klaar is om scripts uit te voeren.

Start je favoriete teksteditor en voer dit PHP-script in:

<?php
PHPinfo();
?>

Een teksteditor zoals Notepad++ ondersteunt je bij het programmeren met een syntax-markering.

PHP-scripts zijn altijd volgens hetzelfde schema opgebouwd. De PHP-openingstag <?PHP geeft aan dat er een scriptomgeving wordt gestart. Dit wordt gevolgd door de eigenlijke PHP-code in de vorm van instructies. In het voorbeeld is dit de PHPinfo()-functieoproep. De meeste functies vereisen een of meer parameters tussen ronde haakjes, maar voor PHPinfo() zijn deze optioneel: PHPinfo(INFO_ALL). Elke stelling eindigt met een puntkomma (;). Om de scriptomgeving te sluiten, gebruik je de PHP-afsluittag: ?>.

Sla het tekstbestand op onder de naam test in format .php (PHP-script) en start je webserver. Als je de XAMPP-testomgeving gebruikt, plaats je test.php in de XAMPP-directory onder htdocs (C:\xampp\htdocs).

Je slaat het bestand test.php op in de map htdocs van je XAMPP-installatie.

Nu kun je het testbestand via de volgende URL in je browser benaderen:

http://localhost/test.php

Gebruik je een andere webserver of een individuele configuratie van de XAMPP-software, selecteer dan de URL volgens het betreffende bestandspad.

Met de URL http://localhost/test.php geef je de webbrowser opdracht om het bestand test.php van de webserver te laden. De webserver haalt het bestand dan eerst op uit de juiste directory. De extensie .php vertelt de webserversoftware dat het bestand PHP-code bevat. En omdat de PHP-interpreter in de webserver is geïntegreerd, wordt deze hierdoor gestart. Deze interpreter leest het document, komt de PHP-openingstag <?php tegen en weet dat deze het begin van een stuk PHP-code markeert. De interpreter kan deze PHP-code vervolgens uitvoeren en een HTML-uitvoer genereren, die de webserver vervolgens doorstuurt naar de browser van de bezoeker.

Als PHP correct is geïnstalleerd, zie je nu de volgende webpagina, als resultaat van de uitvoering van het script:

Als je een script met de functie phpinfo() uitvoert, toont de browser informatie over de PHP-configuratie.

De functie phpinfo() is de afkorting van de standaardwaarde phpinfo(INFO_ALL) en geeft gedetailleerde informatie over de PHP-configuratie van je webserver. Als er geen PHP-versie gevonden kan worden, geeft de webbrowser een foutmelding weer of toont de PHP-code zonder deze te interpreteren.

’Hello World’ - je tekst via echo tonen

Als PHP correct is geïnstalleerd, is het tijd om het eerste eigen script te schrijven. We gebruiken voor dit voorbeeld het echo-commando. In tegenstelling tot phpinfo() is echo geen functie. Het is eerder een taalconstructie die het mogelijk maakt om een volgende string als tekst uit te voeren.

Maak een nieuw PHP-bestand aan voor je eerste script en voer deze code in:

<?php
echo 'Hello World!';
?>

De openingstag <?php start een scriptomgeving. Daarna volgt de taalconstructie echo en de string Hello World! (tussen aanhalingstekens). Met de tag ?> beëindig je het script. Let op de puntkomma na de instructie. In plaats van Hello World! kun je natuurlijk elke tekst gebruiken.

Sla het script op als hello.php in de map htdocs op je webserver en open het bestand via de URL http://localhost/hello.php in de webbrowser. Als de code correct is verzonden, moet het browservenster nu de tekenreeks weergeven die je gebruikt:

Met ‘echo’ geef je de webserver de instructie om de string Hello World! te tonen.

Elke tekst die je met echo uitvoert, kun je markeren met HTML-tags. De browser verwerkt deze volgens de HTML-specificatie. Probeer het maar eens uit, bijvoorbeeld met dit script:

<?php
echo '<h1>Hello World!</h1>
<p>This is my first php page.</p>';
?>

Wanneer je dit in de webbrowser oproept, wordt het resultaat van het script als volgt weergegeven:

Als het resultaat van de scriptuitvoering HTML-tags bevat, interpreteert de browser die automatisch.

De browser interpreteert de string Hello World! als een H1-koptekst. Daarna volgt een automatische regeleinde en een nieuwe alinea, dankzij <p>.

Afhankelijk van je wensen kan echo worden gebruikt met enkele (') of dubbele aanhalingstekens ("). Als je alleen tekst wilt exporteren, maakt het niet uit welke aanhalingstekens je kiest. Dit verandert zodra variabelen in het spel zijn.

Variabelen

De taalconstructie echo heeft meer te bieden dan alleen tekstuitvoer. Je kunt dit natuurlijk ook zonder PHP programmering op basis van HTML-code implementeren. Maar de toegevoegde waarde van echo is dat je de tekst dynamisch kunt maken met behulp van variabelen in combinatie met deze functie.

Variabelen kom je bijvoorbeeld in deze vorm tegen:

$voorbeeld

Elke variabele bestaat uit een dollarteken ($), gevolgd door de naam van de variabele. Variabelen worden gebruikt in PHP-scripts om externe gegevens in webpagina's te integreren. Dit kunnen waarden van verschillende soorten zijn - van eenvoudige getallen en strings tot hele teksten of HTML documentstructuren.

PHP kent zeven typen variabelen:

Het beheer van inhoud gebeurt meestal centraal via het databasesysteem. Waarden voor variabelen kunnen ook direct in het script worden gedefinieerd. Voor dit type opdracht geldt onderstaand schema:

Na het karakteristieke dollarteken volgt de naam van de variabele (in dit geval voorbeeld). Deze is via het is-teken (=) gekoppeld aan de waarde in dubbele aanhalingstekens.

PHP biedt je de vrijheid om variabelen naar eigen goeddunken te benoemen. De volgende beperkingen zijn echter van toepassing:

• Elke variabele begint met een dollarteken.
• Een variabelenaam is een willekeurige reeks letters, cijfers en underscores (bijvoorbeeld $voorbeeld_1).
• Een geldige variabelenaam begint altijd met een letter of underscore ($voorbeeld1 of $_voorbeeld), nooit met een cijfer ($1voorbeeld).
• PHP is case-sensitive en maakt dus onderscheid tussen hoofdletters en kleine letters ($voorbeeld is niet hetzelfde als $Voorbeeld).
• De naam van de variabele mag geen spaties of regeleinden bevatten (fout is dus: $voorbeeld 1)
• Strings die in PHP al voor andere doeleinden zijn gereserveerd, kun je niet als variabelen definiëren (bv. $this)

Laten we eens kijken naar een voorbeeld:

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1> 
<p>This dynamic web page was created by $author.</p>";
?>

Na de inleidende PHP-tag volgt de definitie van de variabele: voor $author moet de waarde John Doe worden gebruikt. Wanneer we het script schrijven, zal de variabele $author dus worden vervangen door de waarde John Doe, elke keer als deze variabele in de scriptomgeving wordt gebruikt. In deze afbeelding zie je hoe dit er in de webbrowser uitziet:

In het resultaat van de scriptuitvoering werd aan de variabele $author de waarde John Doe toegekend.

Als je een fout hebt gemaakt en de webpagina niet door John Doe, maar door zijn Nederlandse collega Jan Jansen is gemaakt, hoef je alleen de variabele met de naam $author aan te passen om de fout te verhelpen.

Voor de variabele $author geldt nu de waarde Jan Jansen.

Dit is vooral efficiënt als een variabele meer dan eens voorkomt in een script. Je hoeft het script dan namelijk maar op één punt te corrigeren. Namelijk daar, waar de waarde van de variabele wordt bepaald.

Dit toont de sterkte van PHP aan: je kunt inhoud als variabelen integreren. Deze functie vormt de basis voor dynamische webontwikkeling. In tegenstelling tot statische webpagina's, die je als kant-en-klare HTML-pagina's bouwt, zijn dynamische webpagina’s pas beschikbaar op het moment dat je de pagina oproept. De PHP-interpreter laadt dan de individuele elementen van de gevraagde webpagina met behulp van variabelen uit verschillende databases en combineert ze vervolgens tot een HTML-pagina die op het verzoek is afgestemd.

De voordelen van dit ontwerpconcept liggen voor de hand: als je onderdelen van de website (bijv. in de footer) herziet, hoef je de aanpassingen niet handmatig op elke subpagina van het webproject door te voeren. In plaats daarvan hoef je alleen maar de overeenkomstige gegevens in de database bij te werken. Op deze manier wordt de revisie automatisch toegepast op alle webpagina's die de corresponderende gegevens als variabelen bevatten.

Als een variabele binnen een script meerdere keren wordt gedefinieerd, overschrijft de nieuwe definitie de vorige. Een volgende echo geeft altijd de actuele waarde van een variabele weer.

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1> 
<p>This dynamic web page was created by $author.</p>";
$author = "Jan Jansen";
echo " <p>Supported by $author.</p>";
?>

De waarde John Doe wordt overschreven met de waarde Jan Jansen.

In het codevoorbeeld wordt eerst de waarde John Doe toegewezen aan de variabele $author en vervolgens vervangen door de waarde Jan Jansen.

En hoe zit het met aanhalingstekens? In tegenstelling tot strings hoef je individuele variabelen niet tussen aanhalingstekens te plaatsen:

<?php
$author = "John Doe";
echo $author;
?>

Dit is alleen anders als je de variabele binnen een string gebruikt. In dit geval gebruik je dubbele aanhalingstekens ("). Deze laten de PHP-interpreter weten dat hij in de string moet zoeken naar variabelen die mogelijk vervangen moeten worden door de waarden die eraan zijn toegekend. Strings die in enkele aanhalingstekens (‘) zijn ingesloten, worden daarentegen als pure tekst geïnterpreteerd en weergegeven, ook al zijn het variabelen. Probeer het zelf eens:

<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';
?>

Enkele aanhalingstekens leiden tot pure tekstuitvoer. Variabelen worden niet geïnterpreteerd.

En wat gebeurt er als je de aanhalingstekens helemaal weglaat? Dan geeft PHP een syntaxfout.

Foutmeldingen en maskering

Als er syntaxfouten optreden, is er geen geldige PHP-code en geeft de PHP-interpreter een foutmelding. Je kunt dit bijvoorbeeld verwachten als je het echo-statement gebruikt met een string zonder aanhalingstekens:

<?php
echo Hello World!;
?>

Foutmeldingen bevatten meestal informatie over de locatie van de fout en leveren zo belangrijke input voor het corrigeren ervan.

Een foutmelding duidt op syntaxfouten in de programmacode.

In het huidige voorbeeld wordt een fout in regel 2 van onze programmacode vermoed - precies waar we de aanhalingstekens voor demonstratiedoeleinden hebben weggelaten.

Syntaxfouten treden ook op als je tekens wilt exporteren als tekst die aan een bepaalde taak in de PHP programmering is gekoppeld. Een voorbeeld hiervan is het aanhalingsteken (‘). Tekens als deze kunnen alleen worden uitgevoerd als tekst in PHP, als je de interpreter laat begrijpen dat het teken niet zijn eigenlijke taak moet vervullen. In het geval van enkele aanhalingstekens heb je twee opties: je kunt een tekenreeks met enkele aanhalingstekens tussen dubbele aanhalingstekens plaatsen óf de aanhalingstekens met een voorafgaande backslash (\) maskeren:

<?php
echo '\'Hello World!\' ';
?>

Als je tekens maskeert met een backslash, worden ze ontbonden van hun functie in de PHP-syntax.

Het is ook mogelijk om enkele en dubbele aanhalingstekens te combineren:

<?php
echo " 'Hello World!' ";
?>

Maar deze schrijfwijze mag niet:

<?php
echo ' 'Hello World!' ';
?>

Vanwege de leesbaarheid hebben we in de voorbeelden overigens extra spaties geplaatst tussen de aanhalingstekens.

Keten-operatoren

We hebben je laten zien hoe je meerdere variabelen tegelijkertijd in een PHP-script kunt uitvoeren. Namelijk op deze manier:

<?php
$author1 = "John Doe";
$author2 = "Jan Jansen";
echo "<h1>Hello World!</h1> 
<p>This dynamic web page was created by $author1 and $author2.</p>";
?>

Je plaatst gewoon beide variabelen samen met de rest van de tekst die je wilt uitvoeren in de string tussen dubbele aanhalingstekens. De PHP programmeertaal herkent de variabelen automatisch door het dollarteken ($) en gebruikt de bijbehorende waarden.

Variabelen in de string worden alleen geaccepteerd door PHP als het script geen functies bevat.

Onder programmeurs geldt deze aanpak echter als slordig. Het dogma stelt dat variabelen geen deel mogen uitmaken van de string. Eén van de redenen hiervoor is dat veel programmeertalen een dergelijke scheiding voorschrijven. Belangrijker nog, PHP programmering vereist ook de scheiding van string en variabele wanneer je gaat werken met functie-calls of complexere variabelen. Het is daarom raadzaam deze scheiding ook bij zuivere tekstoutput consequent toe te passen, ook al is het in dit geval niet strikt noodzakelijk.

Als we met variabelen werken, dan hebben we altijd te maken met meerdere elementen die in de output aan elkaar gekoppeld moeten worden. Hiervoor gebruiken we de keten-operator (.) in PHP.

Als je code van bovenstaand voorbeeld 'schoon' programmeert, ziet het er zo uit:

<?php
$author1 = "John Doe";
$author2 = "Jan Jansen";
echo '<h1>Hello World!</h1> 
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';
?>

Keten-operatoren verbinden strings en variabelen.

We hebben dus te maken met drie strings en twee variabelen, die tot één serie tekens worden samengevoegd.

Merk op dat de keten-operator strings of variabelen samenvoegt zonder spaties. Is een spatie nodig? Schrijf die dan tussen de aanhalingstekens, zoals in het voorbeeld.

Programmeurs gebruiken deze operator niet alleen om strings en variabelen voor tekstoutput te koppelen, maar ook om variabelen te verlengen. Het volgende voorbeeld laat zien hoe dit werkt:

<?php
$example = 'Hello ';
$example .= 'World';
echo $example;
?>

Om de waarde van een variabele te verlengen, herdefinieer je deze, maar zet je de punt van de keten-operator voor het is-teken. Dit is de gebruikelijke afkorting voor $example = $example . 'World'.

PHP voegt de nieuwe waarde toe aan de eerder gedefinieerde waarde. Als je een spatie wilt tussen de twee waarden, schrijf deze dan aan het einde van de eerste string, zoals in het voorbeeld.

De string Hello is uitgebreid naar Hello World.

PHP integreren in HTML

De PHP-interpreter is alleen geïnteresseerd in de code die tussen de begin- en eindtags van PHP staat:

<?php [The PHP interpreter will only read this part] ?>

Alle andere delen van het document worden genegeerd door de interpreter en doorgegeven aan de webserver zoals ze zijn. Je kunt PHP-code dus naar wens in HTML-documenten integreren, bijvoorbeeld om een template te maken voor een systeem. Het is belangrijk om ervoor te zorgen dat HTML-documenten met PHP-code worden opgeslagen als PHP-bestanden. Anders komt het document niet ter voorbereiding terecht bij de PHP-interpreter, maar gaat het rechtstreeks naar de webbrowser - waardoor de programmeercode als tekst in de website verschijnt.

Je kunt je de PHP-interpreter voorstellen als de luie collega van de webserver, die alleen werkt als je hem erom vraagt - bijvoorbeeld door een PHP-openingstag.

Wil je HTML en PHP combineren? Schrijf dan de HTML-pagina zoals gebruikelijk volgens de klassieke documentstructuur en sla deze op met de .PHP-bestandsextensie:

<!DOCTYPE html>
<html lang="nl">
  <head>
    <meta charset="utf-8">
    <title>My first PHP page</title>
  </head>
    <body>
  <h1>Hello World</h1>
  <p>What is the current time and date?</p>
  </body>
</html>

Breid vervolgens je HTML-pagina uit met een PHP-script en let er daarbij op dat de volledige code tussen de PHP-tags staat.

<!DOCTYPE html>
<html lang="nl">
  <head>
    <meta charset="utf-8">
    <title>My first PHP page</title>
  </head>
  <body>
  <h1>Hello World</h1>
  <p>What is the current time and date?</p>
  <p>Your current time and date is: 
  <?PHP 
  echo date("d.m.Y H:i:s");
  ?>.</p>
  </body>
</html>

In het voorbeeld hebben we de echo-taalconstructie gecombineerd met de functie date() om de huidige datum en tijd aan de serverzijde als tekstuitvoer te verstrekken. De parameter van de functie specificeert het gewenste formaat in de vorm van een string:

d.m.Y H:i:s = dag.maand.jaar uur.minuut.seconde

Wanneer de webbrowser dit bestand oproept, zal de PHP-interpreter eerst het script uitvoeren en de huidige datum en tijd in tekstformaat in het HTML document schrijven. Deze wordt vervolgens door de webserver afgeleverd en in de browser als een webpagina weergegeven.

Het HTML document bevat een geïntegreerd PHP script dat de huidige datum en tijd weergeeft.

De PHP-commentaarfunctie

Net als HTML-code kan PHP naar wens van commentaar worden voorzien. De PHP-interpreter negeert commentaar in de broncode zolang die gemarkeerd is volgens de syntaxis. PHP programmering biedt drie mogelijkheden om dit te doen.

Als je een hele regel als commentaar wilt markeren en van de interpretatie wilt uitsluiten, gebruik je de hashtag (#) of twee opeenvolgende slashes (//). In het volgende codevoorbeeld worden beide opties gebruikt:

<?php
#This is a single-line comment!
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
//This is also a single-line comment!
?>

De teksteditor Notepad++ markeert commentaar automatisch groen. Tekstpassages die in de scriptomgeving als commentaar zijn gemarkeerd, komen niet terecht bij de webbrowser, omdat ze in tegenstelling tot HTML commentaren door de PHP-interpreter worden genegeerd wanneer het script draait.

Regels die als commentaar zijn gemarkeerd, zijn niet zichtbaar in de tekstuitvoer.

Je kunt ook commentaren invoegen die meerdere regels beslaan. Markeer hiervoor het begin van een commentaarsectie met een slash gevolgd door een sterretje (/*) en het einde met een sterretje gevolgd door een slash (*/).

<?php
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>

Ook commentaren die je op deze manier invoert, worden door de interpreter genegeerd en verschijnen dus niet op de website.

Het commentaar van meerdere regels is in de tekstuitvoer niet zichtbaar.

Programmeurs gebruiken commentaar om de broncode van hun scripts te structureren, notities achter te laten voor latere bewerkingen of interne informatie toe te voegen, zoals auteur en datum.

Commentaar is optioneel. Gebruik het met mate, omdat anders de broncode slecht leesbaar wordt.

Rekenen met variabelen

In onze PHP-tutorial heb je al met variabelen gewerkt. Ze kregen in de eerste plaats stringwaarden toegewezen. Nu gaan we in op variabelen die integers (gehele getallen) of floats (zwevende komma-getallen) weergeven.

Als je numerieke waarden aan variabelen toekent, kun je de PHP programmeertaal voor berekeningen gebruiken. We beginnen met een eenvoudige optelsom van twee gehele getallen:

<?php
$number1 = 237;
$number2 = 148;
$result = $number1 + $number2;
echo "Result: " . $result;
?>

Eerst wijzen we de gehele getallen 237 en 148 toe aan de variabelen $number1 en $number2 en definiëren we een variabele $result. Die slaat de som van de variabelen $number1 en $number2 op. Hiervoor gebruiken we de rekenkundige operator + (plus). Tot slot gebruiken we de taalconstructie echo om het resultaat van de som als tekst uit te voeren. Let erop dat je geen aanhalingstekens nodig hebt bij het toekennen van numerieke waarden aan variabelen.

Het resultaat van de som is als tekst in de browser zichtbaar.

Het volgende codevoorbeeld toont enkele wiskundige berekeningen die je op de server met PHP kunt uitvoeren. De gebruikte operatoren komen grotendeels overeen met de gestandaardiseerde wiskundige tekens.

<?php
$number1 = 10;
$number2 = 5;
$addition = $number1 + $number2; //Addition
$subtraction = $number1 - $number2; //Subtraction
$multiplication = $number1 * $number2; //Multiplication
$division = $number1 / $number2; //Division 
$exponentiation = $number1 ** $number2; //Exponentiation
?>
<?PHP 
echo "Resultaat van het optellen: " . $addition ."<br />"; 
echo "Resultaat van het aftrekken: " . $subtraction . "<br />"; 
echo "Resultaat van de vermenigvuldigen: " . $multiplication . "<br />";
echo "Resultaat van het delen: " . $division . "<br />";
echo "10 tot de macht 5 (10^5): " . $exponentiation . "<br />";
echo "Wortel van 81: " . sqrt(81) . "<br />";
?>

Een overzicht van berekeningen met variabelen.

Voor complexe berekeningen kun je de verschillende rekenkundige bewerkingen in een script combineren:

<?php
$number1 = 10;
$number2 = 5;
$result = 2 * $number1 + 5 * $number2 - 3 * sqrt(81);
echo "Result: " . $result; 
?>

De PHP-interpreter zoekt de waarden van de variabelen op en berekent ze:

2 * 10 + 5 * 5 - 3 * √81 = 20 + 25 – 27 = 18

De functie sqrt() berekent overigens de wortel van de parameters tussen haakjes. De klassieke rangschikking van wiskundige operatoren geldt: ‘Meneer van Dalen wacht op antwoord’ (eerst Machtsverheffen, dan Vermenigvuldigen, dan Delen, dan Worteltrekken en tenslotte Optellen en Aftrekken).

Via echo wordt het resultaat als string naar de webbrowser gestuurd.

Termen die tussen haakjes staan, gebruikt PHP als eerste. Dit keer werken we met drijvende-kommagetallen:

<?php
$number1 = 2.5;
$number2 = 3.7;
$result = 2 * ($number1 + 5) * ($number2 - 3) * sqrt(81);
echo "Result: " . $result; 
?>

PHP berekent 2* (2,3+5)* (3,9-3)*? 81 en voert het resultaat 118,26 uit.

Net als alle gangbare programmeertalen ondersteunt PHP operatoren om numerieke waarden met 1 te verhogen of te verlagen. Er zijn vier operatoren: pre-increment, pre-decrement, post-increment en post-decrement.

<?php
$number = 0;
$result = ++$number;
echo "Result: " . $result;
?>

Als je de waarde 0 met 1 verhoogt, krijg je resultaat 1.

De operator ++ verhoogt 0 met de waarde 1.

Om de pre-decrement van de variabele $number te berekenen, gebruiken we hetzelfde script, maar we vervangen de pre-incrementele operator (++) door de pre-decrementele operator (--):

<?php
$number = 0;
$result = --$number;
echo "Result: " . $result;
?>

Zo verlagen we dus de waarde 0 van de $number-variabele en krijgen we het resultaat -1.

De operator -- verlaagt het getal 0 met de waarde 1.

Hoe een verhoging van een waarde voor en na de uitvoer plaatsvindt (pre versus post) zie je in dit script:

&+t;?php
$x = 0;
echo '<p>Result: ' . ++$x;
echo '<br>x has the value ' . $x;
echo '<p>Result: ' . $x++;
echo '<br>x has the value ' . $x, '</p>';
?>

In beide gevallen krijgen we hetzelfde resultaat. In het geval van pre-incrementatie wordt de waarde x vóór uitvoer in regel 3 verhoogd en in het geval van post-incrementatie ná uitvoer in regel 5.

Het verschil tussen pre- en post-incrementatie in vergelijking.

De superglobals $_GET en $_POST

Je kent nu de basisprincipes van PHP en je weet om te gaan met variabelen. Je kunt ze aan elkaar koppelen en berekeningen maken. Nu laten we je zien waarom variabelen centraal staan in scriptprogrammering.

Een belangrijke functie van scripttalen is de mogelijkheid om de gebruikersinput te evalueren en de waarden naar een ander script over te dragen. PHP vertrouwt op de superglobals $_GET en $_POST - voorgedefinieerde systeemvariabelen die beschikbaar zijn in elke vorm van geldigheid. $_GET en $_POST zijn associatieve arrays (gegevensvelden) die een set variabelen opslaan als strings in een variabele.

Je kunt arrays zien als een kast met meerdere laden. Elk van deze laden biedt je de mogelijkheid om gegevens op te slaan. Om er zeker van te zijn dat je weet wat er in welke lade zit, moet je de naam van een variabele op de lade schrijven. Afhankelijk van het type array kan dit een index of een sleutel zijn. Bij geïndexeerde arrays ken je een getal als index toe aan elke lade, bij een associatieve array gebruik je een key in de vorm van een string.

De superglobals $_GET en $_POST bevatten een reeks variabelen in de vorm van sleutels (keys) die je toegang geven tot de waarden die met deze sleutels geassocieerd zijn. We komen er dadelijk op terug, als we de superglobals $_GET en $_POST in detail bekijken.

Gegevensoverdracht via $_GET

De superglobal $_GET staat voor een reeks variabelen die aan een PHP-script worden doorgegeven met behulp van een URL. Als je een blog, webshop of forum bezoekt, zie je vaak vreemde URL's. Meestal zien ze er zo uit:

Bij een weblog zie je bijvoorbeeld dit:

Zo'n URL kun je gemakkelijk herleiden: op een webserver met het domein example.com staat een bestand index.php dat dient om een dynamische website te creëren. Het bestand bevat meestal HTML- en PHP-code en verwijzingen naar externe sjabloonbestanden en stylesheets. Kortom, alles wat nodig is om een website weer te geven. Dat het waarschijnlijk een dynamische webpagina is, blijkt uit de toevoeging na het vraagteken (?): id=1. Dit is de zogenaamde HTTP query string en bevat een variabele (id) en een waarde (1) die met een is-teken (=) wordt geassocieerd. Dit soort URL-parameters wordt bijvoorbeeld gebruikt om een dynamische webpagina te creëren, inhoud uit een database te laden of een geschikt sjabloon op te roepen.

Dynamische webpagina's maken een scheiding van inhoud en presentatie mogelijk. Het bestand index.php bevat alle informatie over de structuur van de website, maar moet gevuld worden met inhoud. Deze ligt meestal opgeslagen in een database en kan worden opgehaald met behulp van de parameters in de HTTP query string. In ons voorbeeld verstrekt de URL de parameter id=1 aan index.php, die specificeert welke inhoud uit de database moet worden gelezen en in index.php moet worden geladen. Een weblog is meestal de ID van een bepaald artikel. In een forum kun je met het ID een post benaderen, in een webshop verwijst het ID naar een product.

Heeft een URL meer dan één parameter? Dan worden die met een ampersand (&) gekoppeld.

We kunnen $_GET met een codevoorbeeld illustreren, zonder een database nodig te hebben. In het volgende script gebruiken we de superglobal $_GET om de waarden van de variabelen forename en surname uit een HTTP query string te lezen en deze naar de PHP-variabele $variable1 en $variable2 te schrijven:

<?php
$variable1 = $_GET['forename'];
$variable2 = $_GET['surname'];
echo "Hello " . $variable1 . " " . $variable2 . "!";
?>

We roepen het script op via deze URL:

We voeren dus de parameters forename=John en surname=Doe in. De uitvoer vindt plaats op de bekende manier, via de echo-taalconstructie.

De URL-parameters voegen de variabelen forename=John en surname=Doe toe aan het script.

Gegevensoverdracht via $_GET leidt er onvermijdelijk toe dat de gegevens zichtbaar worden in de adresregel. Hierdoor is het altijd mogelijk om na te gaan welke parameters worden overgedragen. Dit heeft als voordeel dat je variabelen in een link kunt opnemen. Ook kunnen internetgebruikers bookmark-URL's aanmaken, inclusief HTTP query strings in de browser.

Omdat GET-parameters als platte tekst in de URL staan, is deze methode echter niet geschikt voor de overdracht van gevoelige gegevens, zoals online formulieren. Ook blijft de hoeveelheid gegevens die met $_GET kan worden overgedragen, beperkt. Dit omdat een URL een maximale lengte kent.

Deze beperkingen kun je met de HTTP-methode POST omzeilen. De gegevens die je met deze methode overdraagt, zijn terug te vinden in de superglobal $_POST.

Gegevensoverdracht via $_POST

De GET-methode verstrekt gegevens als URL-parameters, maar $_POST verstuurt gegevens in de body van een HTTP-verzoek. Dit stelt ontwikkelaars in staat om grote hoeveelheden gegevens van het ene script naar het andere over te dragen.

Een veel gebruikte toepassing van de HTTP POST-methode is de overdracht van HTML-formuliergegevens. Dit illustreren we met een voorbeeld van een nieuwsbriefregistratie.

Maak een nieuw PHP-bestand aan met de naam page1.php en kopieer het volgende codeblok:

<form method="post" action="page2.php" >
Please send the newsletter to: <br />
Forename: <input type="text" name="forename" /><br />
Surname: <input type="text" name="surname" /><br />
Email address: <input type="text" name="email" /><br />
<input type="submit" value="Submit form" />
</form>

Voor het creëren van formulieren gebruik je het HTML-element <form>. Deze bevat twee attributen in de starttag: method en action. Het method-attribuut gebruik je om de overdrachtsmethode te definiëren, in dit geval HTTP-POST. Het action-attribuut slaat de URL op van een script dat alle gegevens ontvangt die in de velden van het formulier zijn ingevoerd. Het voorbeeld toont een HTML-formulier met drie invoerelementen (input type="text") en een verzendtoets (input type="submit"). Het bestand page2.php is gedefinieerd als de ontvanger van de gegevens.

Om de gegevensoverdracht met $_POST te illustreren, gebruiken we een eenvoudig script voor het evalueren van de formuliergegevens, die de verzonden waarden als PHP-variabelen opslaat en ze in tekstvorm verstuurt. Maak een bestand page2.php en voeg de volgende programmacode in:

<?php
$forename = $_POST["forename"];
$surname = $_POST["surname"];
$email = $_POST["email"]; 
echo "Hello " . $forename . " " . $surname . ", 
 
You are registered with the following email address: " . $email . ".";
?>

Sla de twee PHP-bestanden op in de map htdocs van je testserver en roep page1.PHP op in je browser via deze volgende URL: localhost/page1.PHP. Je browser toont nu de interactieve webinterface van je HTML-formulier.

Het HTML-formulier page1.PHP verzamelt gebruikersgegevens en stuurt deze met het adres page2.php naar het script.

Voer alle gegevens in en druk op de verzendknop om variabelen van het ene script naar het andere over te dragen. Zodra je de invoer op page1.php hebt bevestigd, word je doorgestuurd naar page2.php. Het browservenster toont het resultaat van de scriptuitvoering op basis van de verzonden gegevens.

Gegevensverwerking via HTTP POST en uitvoer via echo

Page2.php gebruikt het volgende schema om de gebruikersgegevens op te vragen die via de invoervelden van page1.php zijn verzameld:

$_POST["Name of the input field"]

Zo haalt de regel $forename = $_POST["forename"] de invoer op in het invoerveld forename en slaat deze op in de variabele $forename. De variabele $forename kun je als string uitvoeren via echo.

De if-constructie en vergelijkende operatoren

Tot nu toe hebben we variabelen gedefinieerd, ze van het ene script naar het andere overgedragen en als een string uitgevoerd. In de volgende stap leer je hoe je de uitvoering van codefragmenten aan voorwaarden kunt koppelen.

Met de taalconstructie if kun je scripts schrijven waarin instructies alleen gelden als is voldaan aan een voorwaarde, die je eveneens zelf definieert. Zoals het invoeren van een correct wachtwoord. In PHP definiëren we voorwaarden volgens dit principe:

<?PHP
if(expression)
   {
   statement;
   }
?>

Het werkt als volgt: het statement wordt alleen uitgevoerd als is voldaan aan de voorwaarde die in de expression staat. En dat is alleen het geval als de if-constructie de waarde TRUE geeft. Anders wordt het beschouwd als FALSE, waardoor het script het statement overslaat.

De if-constructie controleert meestal of de waarde van een variabele overeenkomt met wat in de voorwaarde is gedefinieerd. Dit doe je gewoonlijk met vergelijkende operatoren.

Gegevensoverdracht via $_POST

Vergelijkende operatoren gebruik je bij het formuleren van voorwaarden om twee argumenten in een logische relatie te plaatsen en vervolgens te beoordelen of deze relatie waar (TRUE) of niet waar (FALSE) is. Als je vergelijkende operatoren gebruikt in PHP, worden ze toegepast op twee variabelen in de expression van de if-constructie:

if ($a == $b) 
   {
   statement;
   }

Deze controlestructuur betekent: als variabele $a gelijk is aan variabele $b, worden de commando’s uitgevoerd die in het statement staan.

De vergelijkende operatoren in PHP zijn gebaseerd op de programmeertaal C en verschillen soms fors van de klassieke wiskundige symbolen. In onderstaande tabel vind je een overzicht.

Het volgende script is bedoeld om deze controlestructuur te verduidelijken. We vergelijken twee gehele getallen via de operator < (is kleiner):

<?php
$number1 = 10;
$number2 = 20;
if($number1 < $number2) { 
    echo "The condition is fulfilled";
}

We definiëren de variabelen $number1 en $number2 en kennen er de waarden 10 en 20 aan toe. Vervolgens stellen we een voorwaarde op: als $number1 kleiner is dan $number2, moet de string worden uitgevoerd die in het echo-statement staat.

Het resultaat van het script bevat het antwoord: 10 is kleiner dan 20, dus de if-constructie geeft het resultaat TRUE. Er is voldaan aan de voorwaarde.

Als aan de voorwaarde is voldaan, wordt de verklaring uitgevoerd.

Wil je een commando definiëren dat wordt uitgevoerd als de voorwaarde juist niet is vervuld? Gebruik dan de taalconstructie else if-constructie. Dit doe je als volgt:

<?php
if(Condition a)
    {
    Command b;
    }
else 
    {
    Command c
    }
?>

Ook dit script controleert of voorwaarde a het resultaat TRUE of FALSE geeft. Als aan voorwaarde a is voldaan (TRUE) wordt opdracht b uitgevoerd. Is voorwaarde a niet vervuld (FALSE)? Dan slaat het script de opdracht b over en voert het opdracht c uit.

We breiden ons script met de else-constructie verder uit en vervangen de vergelijkende operator < (is kleiner dan) door == (is gelijk aan):

<?php
$number1 = 10;
$number2 = 20;
if($number1 == $number2) 
    { 
    echo "The condition is fulfilled";
    }
else 
    {
    echo "The condition is not fulfilled";
    }
?>

Deze keer geeft de if-constructie het resultaat FALSE. De waarde van de variabele $number1 is immers niet gelijk aan de waarde van $number2, aan de voorwaarde is niet voldaan. Daarom voert het script de opdracht niet onder if uit, maar onder else.

Is niet aan de voorwaarde voldaan? Dan voert het script de opdracht onder ‘else’ uit.

Het maken van negatieve voorwaarden is ook mogelijk. Hiervoor plaats je uitroepteken (!) vóór de uitdrukking.

<?PHP
$number1 = 10;
$number2 = 20;
if ($number1 == $number2) 
    { 
    echo "The numbers are equal.";
    }
if (!($number1 == $number2))
    {
    echo "The numbers are not equal.";
    }
?>

Dit voorbeeld toont de voorwaarde $number1 == $number2 en de negatieve versie (‘is niet gelijk’) ervan. !($number1 == $number2) betekent dus hetzelfde als ($number1 != $number2).

We geven een voorbeeld van de toepassing van if en else met een HTML-formulier dat om een wachtwoord vraagt. Hiertoe gebruiken we opnieuw onze PHP-bestanden page1.php en page2.php.

Open page1.php en voeg de volgende code toe aan het formulier:

<form action="page2.php" method="post">
Please enter your password: <input type="password" name="password" />
<input type="submit" value="Submit" />
</form>

De structuur komt overeen met het formulier dat je eerder maakte. Dit keer is één invoerveld voldoende: het veld waarin je het wachtwoord moet invoeren. Ook deze keer stuurt het script de uitvoer naar page2.php. We voegen de volgende code toe, waarmee we het ingevoerde wachtwoord vergelijken met een reeds opgeslagen wachtwoord:

<?PHP
$password = $_POST["password"];
if($password=="qwerty123")
   {
   echo "The password was correct";
   }
else
   {
   echo "The password was incorrect";
   }
?>

De code werkt als volgt: eerst kennen we een waarde toe aan de variabele $password in regel 2, die we via de HTTP POST-methode ophalen. Vervolgens definiëren we deze besturingsstructuur: de if-constructie in regel 3 moet controleren of de waarde van $password overeenkomt met de string qwertz123. Als dit het geval is, voert het script de string ‘The password was correct’ uit. Is het resultaat FALSE? Dan treedt else in regel 7 in werking en voert het script de string ‘The password is incorrect’ uit.

Nu gaan we naar het script page1.php via de URL http://localhost/page1.php.

Het HTML-formulier vraagt je om je wachtwoord in te voeren.

De browser toont de webversie van ons HTML-wachtwoordformulier. We voeren het wachtwoord qwertz123 in zoals gedefinieerd in het script page2.php en klikken op de verzendknop.

Het script bevestigt de correcte wachtwoordinvoer.

De browser stuurt je automatisch door naar page2.php. Op de achtergrond vergelijkt de if-constructie onze invoer met het opgeslagen wachtwoord, concludeert dat ‘qwertz123 == qwertz123 is TRUE’ en voert de string ‘The password was correct’ uit.

Test zelf wat er gebeurt als je een ander wachtwoord in het invoerveld typt.

Logische operatoren

Definieer je voorwaarden met behulp van vergelijkende operatoren in de expression van de if-constructie? Dan kun je deze ook koppelen aan andere voorwaarden in dezelfde expression. In PHP doe je dit met de logische operatoren AND en OR.

Om voorwaarden te koppelen kun je in PHP logische operatoren met sterke en zwakke bindingen gebruiken. Als je slechts één van de twee spellingswijzen gebruikt, merk je in de praktijk geen verschil. Combineer je beide spellingen? Dan ontdek je dat OR en || sterker verbonden zijn dan AND en OR. Ook AND en && zijn sterker verbonden dan OR en ||. Dit is vergelijkbaar met de volgorde van wiskundige operatoren (bijv. punt voor streepje: * is sterker dan +).

Een praktisch voorbeeld is de wachtwoordvraag. In de regel zijn inloggegevens voorzien van een geheim wachtwoord en een gebruikersnaam. Het inloggen is alleen succesvol als beide invoergegevens overeenkomen met de in het systeem opgeslagen gegevens.

We openen ons formulier voor de wachtwoordvraag in page1.php opnieuw en voegen een invoerveld voor de gebruikersnaam toe:

<form action="page2.php" method="post">
Username: <input type="text" name="username" /><br />
Password: <input type="password" name="password" /><br />
<input type="submit" value="send" />
</form>

In de volgende stap moeten we ook de controlestructuur van de if-constructie aanpassen. Hiervoor gebruiken we de logische operator AND om de voorwaarde voor het opvragen van het wachtwoord te koppelen aan een voorwaarde voor het opvragen van de gebruikersnaam.

<?PHP
$username = $_POST["username"];
$password = $_POST["password"];

if($username=="John Doe" AND $password=="qwertz123")
   {
   echo "Welcome to the internal area " . $username . "!";
   }
else
   {
   echo "Access denied";
   }
?>

Ons script page2.php krijgt nu de waarden voor username en password en slaat deze op in de variabelen $username en $password. De expression van de if-constructie bevat nu twee voorwaarden die gekoppeld zijn aan de logische operator AND. Alleen als aan beide voorwaarden is voldaan (username=="John Doe" en $password=="qwertz123"), wordt het resultaat TRUE afgegeven.

Omdat we de gebruikersnaam krijgen via het invoerveld username, kunnen we deze direct gebruiken voor de tekstuitvoer via echo. Na de welkomstboodschap volgt de waarde van de variabele $username. Als een van de twee voorwaarden niet is vervuld, ontvangen we de melding: Access denied.

Alleen als aan beide voorwaarden is voldaan, bevestigt het script de correcte wachtwoordinvoer.

Je kunt logische operatoren naar wens combineren. Het volgende is van toepassing: AND heeft een hogere prioriteit voor de operator dan OR. Net als bij wiskundige vergelijkingen kun je ook haakjes in PHP gebruiken om de ranking te beïnvloeden.

Lussen (while, for)

Soms is het nodig dat een script meerdere keren een deel van de code uitvoert, voordat het naar de rest van de programmacode springt. Programmeertalen, zo ook PHP programmering, gebruiken hiervoor een lus (loop). Er zijn drie soorten lussen:

• while-lus
• do-while-lus
• for-lus

While-lussen

De while-lus is het eenvoudigste type lus in PHP. De basisstructuur is als volgt:

while (Expression)
    {
    Loop step and other instructions
    }

De while lus instrueert PHP om de bijbehorende subopdrachten uit te voeren zolang de while voorwaarde vervuld blijft. De PHP-interpreter controleert deze toestand opnieuw bij elke start van de lus. De uitvoering van de code stopt pas als niet langer aan de voorwaarde while is voldaan.

Dit principe kan worden geïllustreerd met een eenvoudig telscript:

<?php
$number = 1;
while ($number <= 10) {
    echo $number++ . "<br />";  
    }
  ?>

In het hoofdstuk ‘Rekenen met variabelen’ hebben we het telprincipe al uitgelegd. In het volgende script gebruiken we het, maar dit keer gebruiken we een post-increment-operator om de waarde van de integere variabele $number per uitgevoerde lus ná de tekstuitvoer per echo te verhogen met 1. Als voorwaarde voor de while-lus bepalen we dat $number kleiner dan of gelijk moet zijn aan 10. De echo wordt dus herhaald tot $number een waarde groter dan 10 bereikt.

Het script telt tot 10 door $number te verhogen, tot een waarde groter dan 10 is bereikt.

Het resultaat van het script is een string die de waarde van $number voor elke uitgevoerde lus uitvoert, waarna het script de waarde verhoogt. Het script telt dus van 1 tot 10 en stopt zodra niet langer aan de voorwaarde wordt voldaan.

Do-while-lussen

De structuur van de do-while-lus is vergelijkbaar met die van de while-lus. Het enige verschil is dat de voorwaarde niet aan het begin van elke uitgevoerde lus wordt gecontroleerd, maar aan het einde. Het schema van een do-while-lus is als volgt:

do {
    Loop steps and other instructions
    } 
   while (condition)

Als we het vorige script als do-while script programmeren, ziet het er zo uit:

<?php
$number = 1;
do {
    echo $number++ . "<br />";
    }
while ($number <= 10); 
  ?>

In dit geval blijft het resultaat hetzelfde. Maar het bijzondere aan deze lus is dat de code minstens één keer wordt uitgevoerd, ook als in de lus niet aan de voorwaarde wordt voldaan.

For-lussen

In principe heeft de for-lus in een PHP-script dezelfde functionaliteit als de while-lus. Maar in de for-lus staan de startwaarde, voorwaarde en opdracht op één regel en niet verdeeld over drie of meer regels. De basisstructuur van de for-lus is dus als volgt:

Het voorbeeldscript hierboven kun je met de for-lus dus korter schrijven:

<?PHP
for($number = 1; $number >= 10; $number++) {
   echo $getal . "<br /> ";
}
?>

Eerst wordt de waarde 1 gedefinieerd voor de variabele $number. Dan controleert PHP of de voorwaarde $number <= 10 is vervuld . Als dit het geval is, gaat de lus door en worden de opdrachten onder de lus uitgevoerd (hier de echo-opdracht). Pas daarna gaat de lus naar de volgende stap. In dit geval maakt het dus niet uit of je pre of post-incrementering hanteert, want deze opdracht vindt altijd vóór de uitvoer plaats. Wanneer de lus-stap is afgesloten, start de lus opnieuw.

Startwaarde, voorwaarde en lus-stap zijn in de for-lus optioneel. Theoretisch zijn ook lege lussen mogelijk (al zouden deze dan overbodig zijn).

Je bepaalt zelf of je PHP-scripts schrijft met een for of while-lus, maar één argument pleit voor de for-versie: met deze lus heb je een beter overzicht op de basisgegevens in de lus. Daarmee daalt het risico op fouten die tot een eeuwigdurende lus leiden, ofwel een lus die blijft draaien tot het geheugen van de interpreter vol is. Dit gebeurt in het bovengenoemde script bijvoorbeeld als je vergeet om de waarde van $number te verhogen.

Wil je de lus ongeacht de voorwaarde minimaal één keer laten uitvoeren? Dan kan dat alleen met de do-while-lus.

Break en continue

Je kunt de uitvoering van een while, do-while en for-lus beïnvloeden met de opdrachten break en continue. Met break las je een pauze in om de lus tijdelijk te onderbreken, met continue dwing je de lus om één ‘rondje’ over te slaan. Beide opdrachten zijn via if aan een voorwaarde gebonden. Het volgende voorbeeld toont ons het script met een break:

<?php
for ($number = 1; $number <= 10; $number++) {
    if ($number == 5) {
      echo "The script stops at 5";
      break;
    }
echo $number . "<br /> ";
}
?>

In de for-lus hebben we bepaald dat de waarde van $number begint bij 1 en ook telkens met 1 wordt verhoogd tot deze variabele 10 bereikt. Deze lus stopt nu voortijdig via de break-opdracht zodra $number de waarde 5 bereikt. De echo-taalconstructie levert dus alleen de getallen 1 tot en met 4.

De opdracht break stopt de lus zodra aan de voorwaarde is voldaan.

Als we alleen de vijfde ronde willen overslaan en de lus daarna willen laten doortellen, gebruiken we de opdracht continue in plaats van break:

<?php
for ($number=1; $number <= 10; $number++) {
    if ($number == 5) {
      echo "We skip number 5!<br />";
      continue;
    }
echo $number . "<br /> ";
}
?>

In plaats van het cijfer 5 voert PHP de tekststring uit die met if is gedefinieerd, namelijk ‘We skip number 5!’.

De for-lus wordt onderbroken met de opdracht continue.

Bestandsbewerkingen

Dynamische webinhoud is gebaseerd op een scheiding van inhoud en presentatie. Scripttalen zoals PHP bieden daarom verschillende functies waarmee je gegevens uit externe bronnen in centrale template-bestanden kunt laden. In de praktijk zijn deze gegevensbronnen meestal databases onder bekende systemen zoals MySQL. Meer informatie hierover lees je in onze MySQL-tutorial voor beginners.

Je kunt ook gegevens uit bestanden integreren. In dit hoofdstuk laten we je zien hoe je bestanden als strings in een PHP-script kunt importeren en de tekstuitvoer van het script weer in een bestand kunt opslaan.

Bestanden lezen

Om de inhoud van een bestand in te lezen, biedt PHP verschillende functies. De functies file() en file_get_contents() zijn bijzonder handig voor ons doel. Via file _get_contents() laad je de volledige inhoud van een bestand in een string, met file() sla je de inhoud op als een array. Elk element van deze array komt dan overeen met één regel van het bestand. Met file() is het dus eenvoudiger om elke regel afzonderlijk uit te voeren.

We geven een voorbeeld van PHP-bestandsbewerkingen met ons tekstbestand example.txt, dat we opslaan in de map htdocs op onze testserver. Dit bestand bevat vier regels dummytekst:

Lorem ipsum dolor zitten amet, consectetuer adipiscing elite. Aenean commodo ligula eget dolor. Aenees massa. Cum sociis natoque penatibus et magnis dis deel uitmakende montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.

Het tekstbestand example.txt in de map htdocs, met vier regels voorbeeldtekst.

Eerst importeren we het volledige bestand als een string. Hiervoor moeten we de naam van het bestand als parameter aan de file_get_contents ()-functie toekennen. Dit schema ziet er zo uit:

Nu kunnen we met de geïmporteerde string werken, door er bijvoorbeeld een variabele aan toe te wijzen en de tekst in de browser te laten zien:

<?php
$example = file_get_contents('example.txt');
echo $example;
?>

Het script leest het bestand example.txt uit en toont het resultaat in de browser.

In de browserweergave zien we dat de string zonder alinea's wordt uitgevoerd. De regeleinden in het oorspronkelijke bestand zijn niet zichtbaar. Dit komt omdat de webbrowser de tekstuitvoer van het script interpreteert als HTML-code. Regeleinden die in een tekstverwerker zijn aangemaakt, gaan dus verloren.

Als je de oorspronkelijke structuur wilt behouden, heb je een paar mogelijkheden. Je kunt handmatig regeleinden (br) toevoegen aan de HTML-codering in het bronbestand via zoeken&vervangen, je kunt <pre> om de inhoud van het bestand heen plaatsen, de CSS-eigenschap white-space:pre-wrap toekennen of de functie nl2br() gebruiken om PHP te vertellen dat regeleinden automatisch moeten worden omgezet naar breaks in HTML. Deze functie heeft het volgende schema:

<?php
$example = file_get_contents('example.txt');
echo nl2br($example);
?>

Gebruik je de echo-taalconstructie in combinatie met nl2br()? Dan voegt PHP voor elke nieuwe regel een HTML-regeleinde in.

De functie nl2br()helpt bij het structureren van geïmporteerde gegevens.

Wil je de regels van een bestand individueel uitvoeren, dan is de functie file() handig. Deze functie leest een bestand, nummert alle regels vanaf 0 en slaat de inhoud op als elementen van een array. Ons voorbeeld ziet er dan zo uit:

[0] = Lorem ipsum dolor sit amet, consectetuer adipiscing elit. [1] = Aenean commodo ligula eget dolor. Aenean massa. [2] = Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. [3] = Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.

Om de desbetreffende inhoud met echo uit te voeren, hoef je alleen het gewenste regelnummer op te geven. Het volgende script stuurt bijvoorbeeld alleen de eerste regel van het bestand example.txt naar de browser:

<?PHP
$example = file("example.txt");
echo $example [0];
?>

Met file() kies je zelf, welk element van de array je wilt uitvoeren.

---

Bestanden schrijven

PHP kan niet alleen bestanden lezen. De scripttaal stelt je ook in staat om bestanden aan te maken en inhoud naar dit bestand te schrijven.

We gebruiken hiervoor de PHP-functie file_put_contents(). Die functie verwacht twee parameters: de naam van het bestand dat aangemaakt of bijgewerkt moet worden, en de gegevens in de vorm van een string of array. Het volgende script maakt het bestand test.txt aan en schrijft de string ‘This is a test!’ naar de eerste regel. De toevoeging \r\n maakt een regeleinde in het doelbestand aan.

<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt was created!.";
?>

Het PHP-script schrijft de string ‘This is a test!’ naar het bestand test.txt.

Omdat file_put_contents ons geen uitvoer voor de browser biedt, voegen we een echo-opdracht toe die ons vertelt wat er gebeurt.

Als er al een bestand met dezelfde naam in de doelmap aanwezig is, dan wordt dit bestand overschreven, tenzij je de parameter FILE_APPEND gebruikt:

<?php
file_put_contents("test.txt","The test was succesful! \r\n", FILE_APPEND);
echo "test.txt was updated!";
?>

Als je file_put_contents() met de parameter FILE_APPEND gebruikt, worden nieuwe gegevens aan bestaande toegevoegd.

Het PHP-script voegt de string ‘The test was successful’ toe aan het bestand test.txt.

Wat PHP schrijft naar het doelbestand, hoeft niet per se gedefinieerd te worden in het script. Je kunt ook inhoud van het ene bestand naar het andere overbrengen. Het volgende script leest de inhoud van example.txt en voegt deze toe aan het bestand test.txt:

<?php
$example = file_get_contents("example.txt");
file_put_contents("test.txt", $example, FILE_APPEND);
echo "test.txt was updated.";
?>

Het PHP-script leest de gegevens uit het bestand voorbeeld.txt en voegt deze toe aan test.txt.

Is hosting je passie? Bij ons zit je goed! Zo leren we je niet enkel de basis, namelijk wat een host is, maar vind je bij Strato ook vergaande informatie over bijvoorbeeld domeinomleiding, DynDNS, HTST-beveiliging of MongoDB.