Aan de slag met PHP – Een tutorial voor beginners
PHP is een van de meest gebruikte programmeertalen voor server-side programmeren. In de loop der tijd is het een integraal onderdeel geworden van hedendaagse websites en internettechnologieën. Toch kan het voor beginners een hele uitdaging zijn om PHP onder de knie te krijgen. In deze PHP-tutorial laten we je de basisprincipes van deze populaire programmeertaal zien, evenals de belangrijkste operatoren, loops en functies.
Wat je nodig hebt voordat je aan de PHP-tutorial begint
Onze tutorial is voornamelijk bedoeld voor beginners. Het kan echter nuttig zijn om enige basiskennis te hebben van moderne webontwikkeling en HTML. Om de voorbeelden op uw eigen computer te kunnen volgen en reproduceren, moet u het volgende bij de hand hebben:
- Webserver inclusief PHP-interpreter
- PHP geïnstalleerd
- Webbrowser
- Teksteditor
Als server raden we de lokale testomgeving XAMPP aan, die Apache Friends gratis aanbiedt voor Windows-, Linux- en macOS-besturingssystemen. XAMPP is een pure testserver. Webontwikkelaars kunnen de software gebruiken om eenvoudig testomgevingen voor scripts, HTML-pagina’s en stylesheets op te zetten. Een veilige werking van de webserver op het internet is echter niet gegarandeerd. Gedetailleerde installatie-instructies vindt u in onze XAMPP-tutorial.
Wat is de syntaxis van PHP?
Zodra u uw lokale webserver hebt ingesteld (bijvoorbeeld met XAMPP), is het een goed idee om te testen of PHP correct is geïnstalleerd en klaar is om scripts uit te voeren. Een script is een programma dat niet is gecompileerd tot binaire code. In plaats daarvan worden ze uitgevoerd door een interpreter. Open uw favoriete teksteditor en pas het volgende PHP-script toe:
<?php
phpinfo();
?>
PHP-scripts volgen een specifieke structuur. De openings-PHP-tag <?php starteen scriptomgeving*. Deze wordt gevolgd door de eigenlijke PHP-code in de vorm van statements. In het bovenstaande voorbeeld is dit de aanroep vande functiephpinfo*(). De meeste PHP-functies vereisen een of meer parameters, die tussen haakjes staan. Voorphpinfo () zijn deze parameters optioneel:phpinfo(INFO_ALL). Elke instructie eindigt met een puntkomma (;). Om het script af te sluiten, gebruikt u de afsluitende PHP-tag:?>.
Functies zijn subroutines waarmee delen van programmacode kunnen worden uitbesteed. Om herhaling te voorkomen, kunnen terugkerende taken eenmalig als functie worden gedefinieerd en vervolgens met een functienaam worden aangeroepen. Webontwikkelaars gebruiken hiervoor vooraf gedefinieerde PHP-functies of maken hun eigen subroutines.
Sla het tekstbestand op onder de naam test in het .php-formaat (PHP-script) en start uw webserver. Als u de testomgeving XAMPP gebruikt, sla test.php dan op in de XAMPP-map onder htdocs (C:\xampp\htdocs).
U kunt het voorbeeldbestand openen via de volgende URL in de webbrowser: http://localhost/test.php. Als u een andere webserver of een individuele configuratie van de XAMPP-software gebruikt, selecteer dan de URL op basis van het betreffende bestandspad.
Wanneer u de URL http://localhost/test.php invoert, vraagt u de webbrowser om het bestand test.php op te halen van de webserver. De Apache HTTP Server (of het type webserversoftware dat u gebruikt) haalt het bestand op uit de juiste map. De extensie .php geeft aan dat het bestand PHP-code bevat. Op dit moment wordt de PHP-interpreter die in de webserver is geïntegreerd, actief. Deze verwerkt het document en komt daarbij de openings-PHP-tag <?php tegen, die het begin van PHP-code aangeeft. De interpreter gaat verder met het uitvoeren van de PHP-code en genereert HTML-uitvoer die de webserver naar de webbrowser verzendt voor weergave. Als PHP correct is geïnstalleerd, resulteert de uitvoering van het script in de volgende webpagina:
De functie phpinfo() is een afkorting voor de standaard phpinfo( INFO_ALL ). Deze functie geeft gedetailleerde informatie weer over de PHP-configuratie van uw webserver. Als er geen PHP-versie kan worden gevonden, geeft de webbrowser een foutmelding weer of levert de PHP-code aan de browser zonder deze te interpreteren.
“Hallo wereld!” – Hoe tekst weergeven met echo
Nadat je PHP met succes hebt geïnstalleerd, is het tijd om je eerste script te schrijven. Je kunt hiervoor PHP echo gebruiken. In tegenstelling tot phpinfo() is echo geen functie. Het is eerder een taalconstructie waarmee een volgende tekenreeks als tekst kan worden weergegeven.
Taalconstructies zijn instructies die in PHP worden gebruikt om de programmastroom te regelen. Naast echo omvatten taalconstructies instructies zoals if, for, do, include, return, exit of the. In tegenstelling tot functies zijn er geen haakjes nodig.
Maak voor uw eerste aangepaste script een nieuw PHP-bestand aan en voer de volgende code in:
<?php
echo 'Hello World!';
?>De openingstag <?php start een scriptomgeving. Deze wordt gevolgd door de taalconstructie echo en de tekenreeks Hello World!, die tussen enkele aanhalingstekens staat. Gebruik de tag ?> om het script te beëindigen. Let op de puntkomma na de instructie. In plaats van Hello World! kan elke tekst worden gebruikt.
Sla het script op als hello.php in de map htdocs op uw webserver. Open vervolgens het bestand via de URL http://localhost/hello.php in uw webbrowser. Als de code correct is overgebracht, zou het browservenster de door u gebruikte tekenreeks moeten weergeven:
Elke tekst die u met echo genereert, kan naar behoefte HTML-tags bevatten. Deze tags worden door de webbrowser geïnterpreteerd in overeenstemming met de HTML-specificaties. Experimenteer met dit concept door bijvoorbeeld het volgende script te gebruiken:
<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>Wanneer het script in de webbrowser wordt aangeroepen, wordt het resultaat van de uitvoering als volgt weergegeven.
De tekst Hello World!, die tussen <h1> tags staat, wordt door de webbrowser geïnterpreteerd als een primaire kop. Deze wordt gevolgd door een automatische regeleinde en de tekstparagraaf tussen de <p> tags.
Afhankelijk van uw vereisten kunt u echo gebruiken met enkele aanhalingstekens (’) of dubbele aanhalingstekens (“). Als u alleen tekst uitvoert, maakt de keuze van de aanhalingstekens niet uit. Dit onderscheid wordt echter belangrijk bij het werken met PHP-variabelen.
Variabelen
De echo-taalconstructie biedt meer dan alleen tekstweergave. Tekstpresentatie kan al effectief worden gerealiseerd met HTML. Het echte voordeel van het gebruik van de PHP echo-taalconstructie ligt in de mogelijkheid om dynamisch tekst te produceren met behulp van variabelen.
PHP-gebruikers komen vaak variabelen tegen in de volgende indeling: $example
Elke variabele bestaat uit een dollarteken ($) gevolgd door de naam van de variabele. Variabelen worden binnen PHP-scripts gebruikt om externe gegevens in webpagina’s op te nemen. Ze kunnen verschillende soorten waarden bevatten, variërend van eenvoudige getallen en tekenreeksen tot volledige teksten of HTML-documentstructuren. PHP maakt onderscheid tussen zeven verschillende variabele typen:
| Variabel type | Beschrijving |
|---|---|
| Tekenreeks | Een string is een reeks tekens. Het kan een woord, een zin, een stuk tekst of zelfs de volledige HTML-code van een webpagina vertegenwoordigen. |
| Geheel getal | Een geheel getal is een getal zonder decimalen. Dit kan positief of negatief zijn. |
| Float | Een float is een drijvende-kommagetal. Dit is een numerieke waarde met decimalen. PHP ondersteunt maximaal 14 cijfers achter de komma. |
| Boolean | Booleaanse variabelen zijn het resultaat van een logische bewerking en kennen slechts twee waarden: TRUE (waar) en FALSE (onwaar). Dit type variabele wordt gebruikt bij het werken met voorwaarden. |
| Array | Een array is een variabele die meerdere elementen kan bevatten. Het is een groep van meerdere gelijk gestructureerde gegevens die zijn gecombineerd in een array. |
| Object | Met het variabele type object kunnen programmeurs hun eigen gegevenstypen definiëren. Het wordt gebruikt in objectgeoriënteerd programmeren. We hebben objectvariabelen opgenomen in deze PHP-tutorial. |
| NULL | De waarde NULL staat voor een variabele zonder waarde. Voor variabelen van dit type is NULL de enige mogelijke waarde. |
Contentcentralisatie wordt doorgaans beheerd via databasesystemen. Niettemin kunnen variabele waarden ook rechtstreeks in het script worden toegewezen. Dit type toewijzing maakt gebruik van het volgende patroon:
$example = "value";Het dollarteken wordt gevolgd door de variabelenaam (in dit geval example). Deze wordt met een gelijkteken (=) gekoppeld aan een waarde tussen dubbele aanhalingstekens. Variabele waarden van het type integer en float worden zonder aanhalingstekens geschreven (bijvoorbeeld $example = 24;en $example= 2.7;).
PHP biedt flexibiliteit bij het benoemen van variabelen. Er gelden echter bepaalde beperkingen:
- Elke variabele begint met een dollarteken.
- Een variabelenaam is een willekeurige reeks letters, cijfers en onderstrepingstekens (bijvoorbeeld $voorbeeld_1).
- Een geldige variabelenaam begint altijd met een letter of een onderstrepingsteken ($voorbeeld1 of $_voorbeeld), nooit met een cijfer (fout: $1voorbeeld).
- PHP is hoofdlettergevoelig. De scripttaal maakt onderscheid tussen hoofdletters en kleine letters ($voorbeeld ≠ $Voorbeeld).
- De variabelenaam mag geen spaties of regeleinden bevatten (fout: $voorbeeld 1).
- Strings die door PHP voor andere doeleinden zijn gereserveerd, kunnen niet als door de gebruiker gedefinieerde variabelen worden gebruikt (bijvoorbeeld*$this*).
Laten we dit illustreren met een voorbeeld:
<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
?>De openings-PHP-tag wordt gevolgd door de definitie van de variabele. In dit geval krijgt $author de waarde John Doe toegewezen. Bij uitvoering van het script wordt elke instantie van de variabele $author in het script vervangen door de waarde John Doe in de scriptomgeving. Een visuele weergave van dit proces in de webbrowser wordt geïllustreerd in het volgende diagram:
Als de webpagina moet worden toegeschreven aan Max Mustermann, de Duitse collega van John Doe, en niet aan John Doe, kunt u dit corrigeren door de variabele $author te wijzigen.
Dit is vooral efficiënt als een variabele meerdere keren in een script voorkomt. In dat geval hoeft er maar op één plek een correctie te worden aangebracht. Namelijk daar waar de waarde van de variabele wordt gedefinieerd.
Dit illustreert de kracht van PHP: inhoud kan worden ingebed met behulp van variabelen. Deze eigenschap vormt de basis van dynamische webontwikkeling. In tegenstelling tot statische webpagina’s, die bestaan als vooraf gerenderde HTML-pagina’s, worden dynamische webpagina’s alleen gegenereerd wanneer de pagina wordt geopend. De PHP-interpreter haalt verschillende elementen van de opgevraagde webpagina uit verschillende databases op via variabelen en compileert deze tot een op maat gemaakte HTML-pagina die aansluit bij de specifieke aanvraag.
De voordelen van deze aanpak zijn duidelijk. Wanneer elementen van de website (bijvoorbeeld in de voettekst) worden gewijzigd, is het niet nodig om elke afzonderlijke subpagina handmatig aan te passen. Het volstaat om de overeenkomstige vermelding in de database bij te werken. Als gevolg daarvan worden de wijzigingen automatisch toegepast op alle webpagina’s die de betreffende gegevens als variabelen bevatten. Als een variabele meerdere keren in een script wordt gedefinieerd, overschrijft de nieuwe definitie de vorige. Een volgende echo geeft altijd de huidige 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 = "Max Mustermann";
echo " <p>Supported by $author.</p>";
?>
In het codevoorbeeld werd aan de variabele $author eerst de waarde John Doe toegekend en vervolgens vervangen door de waarde Max Mustermann.
Nu naar het onderwerp aanhalingstekens. In tegenstelling tot strings hoeven enkele variabelen niet tussen aanhalingstekens te staan:
<?php
$author = "John Doe";
echo $author;
?>Behalve wanneer de variabele binnen een string moet worden gebruikt. Gebruik in dat geval dubbele aanhalingstekens (“). Dit geeft de PHP-interpreter de opdracht om de string te scannen op variabelen en deze indien nodig te vervangen door de bijbehorende waarden. Strings tussen enkele aanhalingstekens (’) worden geïnterpreteerd en weergegeven als gewone tekstinformatie, zelfs wanneer ze variabelen bevatten.
<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';
?>
Je vraagt je nu misschien af wat er gebeurt als je de aanhalingstekens helemaal weglaat. In dat geval wijst PHP op een syntactische fout.
Foutmeldingen en maskering
Als er syntactische fouten optreden, is er geen geldige PHP-code en geeft de PHP-interpreter een foutmelding. Dit kan bijvoorbeeld gebeuren als u de echo-instructie gebruikt met een tekenreeks zonder aanhalingstekens:
<?php
echo Hello World!;
?>Foutmeldingen bevatten in de meeste gevallen informatie over waar een fout is opgetreden, wat belangrijke informatie oplevert voor het verhelpen ervan.
In het huidige voorbeeld wordt een fout vermoed in regel 2 van onze programmacode. Dit is precies waar we de aanhalingstekens hebben weggelaten.
Syntactische fouten treden ook op wanneer u tekens wilt uitvoeren als tekst die gekoppeld zijn aan een specifieke taak in PHP. Een voorbeeld hiervan is het aanhalingsteken (’). Tekens zoals deze kunnen alleen als tekst worden uitgevoerd in PHP als u aan de interpreter aangeeft dat de inherente functie van het teken is geneutraliseerd. In het geval van enkele aanhalingstekens zijn er twee manieren om dit te doen. U kunt een string tussen enkele aanhalingstekens tussen dubbele aanhalingstekens plaatsen, of u kunt de aanhalingstekens maskeren met een voorafgaande backslash (\):
<?php
echo '\'Hello World!\' ';
?>
Het combineren van enkele en dubbele aanhalingstekens is ook een haalbare aanpak:
<?php
echo " 'Hello World!' ";
?>Maar niet deze spelling:
<?php
echo ' 'Hello World!' ';
?>De spaties tussen de aanhalingstekens zijn in de voorbeelden toegevoegd omwille van de leesbaarheid.
Aaneenschakelingoperatoren
Om meerdere variabelen tegelijkertijd binnen een PHP-script uit te voeren, kun je gebruikmaken van wat je tot nu toe hebt geleerd en het volgende doen:
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author1 and $author2.</p>";
?>Schrijf beide variabelen gewoon in de dubbele aanhalingstekens samen met de rest van de tekst die moet worden weergegeven. PHP herkent de variabelen automatisch aan het dollarteken ($) en voegt de juiste waarden in.
Onder programmeurs wordt deze procedure echter als onzuiver beschouwd. Er is een programmeerregel die stelt dat variabelen geen deel mogen uitmaken van de string. Een van de redenen hiervoor is dat veel programmeertalen deze scheiding vereisen. Belangrijker nog is dat PHP ook vereist dat je strings en variabelen scheidt wanneer je werkt met functieaanroepen of complexere variabelen. Daarom is het het beste om ze ook in platte tekstuitvoer gescheiden te houden, zelfs als dat in dit geval niet echt nodig is.
Wanneer u met variabelen werkt, krijgt u altijd te maken met verschillende elementen die tijdens de uitvoer aan elkaar moeten worden gekoppeld. In PHP wordt hiervoor de koppeltekenoperator (.) gebruikt. Als de code voor het bovenstaande voorbeeld ‘netjes’ is geprogrammeerd, zou deze er als volgt uit moeten zien:
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';
?>
Hier hebben we te maken met drie strings en twee variabelen die zijn samengevoegd tot één string.
| String1 | Variabele1 | String2 | Variabele2 | String3 | ||||
|---|---|---|---|---|---|---|---|---|
| ’<h1>Hallo wereld!</h1> <p>Deze dynamische webpagina is gemaakt door ’ | . | $auteur1 | . | ’ en ’ | . | $auteur2 | . | ’.</p>’ |
Het is belangrijk om te vermelden dat een concatenatieoperator strings of variabelen samenvoegt zonder spaties toe te voegen. Als een spatie bedoeld is, moet deze expliciet worden opgenomen tussen de aanhalingstekens binnen de string, zoals in het voorbeeld wordt getoond.
Programmeurs gebruiken de concatenatie-operator niet alleen om strings en variabelen te combineren voor tekstuele uitvoer, maar ook om variabelen uit te breiden. Het volgende voorbeeld illustreert hoe dit wordt gedaan:
<?php
$example = 'Hello ';
$ example .= 'World';
echo $ example;
?>Om de waarde van een variabele uit te breiden, definieer je deze opnieuw, maar plaats je de concatenatie-operator punt (.) voor het gelijkheidsteken. Dit is de gebruikelijke verkorte notatie voor $example = $example . ‘world’.
PHP voegt de nieuwe waarde toe aan de eerder gedefinieerde waarde. Als u een spatie tussen de twee waarden wilt, schrijf deze dan aan het einde van de eerste tekenreeks, zoals in het voorbeeld.
PHP in HTML insluiten
In principe is de PHP-interpreter alleen geïnteresseerd in code die zich tussen een openings- en een sluitings-PHP-tag bevindt:
<?php [This section is parsed by the PHP interpreter] ?>
De interpreter negeert alle resterende delen van het document en stuurt ze zonder wijzigingen door naar de webserver. Hierdoor kan PHP-code naadloos worden geïntegreerd in HTML-documenten wanneer dat nodig is, bijvoorbeeld bij het maken van sjablonen voor contentmanagementsystemen. Het is van cruciaal belang om HTML-documenten met PHP-code op te slaan met de PHP-bestandsextensie. Anders wordt het document rechtstreeks aan de webbrowser gepresenteerd zonder dat het door de PHP-interpreter wordt voorbewerkt. In dat geval zou de code als tekst op de website zichtbaar zijn.
Je kunt de PHP-interpreter zien als de luie collega van de webserver, die alleen werkt wanneer hij daar expliciet om wordt gevraagd, bijvoorbeeld door een openings-PHP-tag.
Om HTML en PHP te combineren, schrijf je je HTML-pagina in de klassieke documentstructuur en sla je deze op onder de bestandsextensie .php:
<html lang="de">
<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>Voeg nu een PHP-script toe aan uw HTML-document. Zorg ervoor dat alle code binnen de PHP-tags staat.
<html lang="de">
<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 dit geval hebben we de taalconstructie echo samengevoegd met de PHP-functie date() om de huidige datum en tijd als server-side tekst weer te geven. De parameter van de functie geeft het gewenste formaat aan, weergegeven als een tekenreeks:
d.m.Y H:i:s = dag.maand.jaar uur:minuut:seconde.
Wanneer een webbrowser een dergelijk bestand opvraagt, voert de PHP-interpreter eerst het script uit en voegt daarbij de huidige tijd als tekst in het HTML-document in. Vervolgens verzendt de webserver dit document, dat vervolgens in de browser als webpagina wordt weergegeven.
PHP-commentaarfunctie
Net als bij HTML-code kunt u ook opmerkingen achterlaten in uw PHP-code. Opmerkingen in de broncode worden door de PHP-interpreter genegeerd, zolang ze maar aan de syntaxisregels voldoen. PHP biedt drie verschillende methoden voor het plaatsen van opmerkingen.
Om een hele regel als opmerking aan te duiden en deze daarmee uit te sluiten van interpretatie, kunt u ofwel de hashtag (#) of twee opeenvolgende schuine strepen (//) gebruiken. Beide opties worden gebruikt in het volgende codevoorbeeld:
<?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 tekstverwerker Notepad++ markeert opmerkingen in het groen. In tegenstelling tot HTML-opmerkingen komen tekstgedeelten die binnen de scriptomgeving als opmerkingen zijn gemarkeerd, niet in de webbrowser terecht. Dit verschil ontstaat omdat de PHP-interpreter ze tijdens de uitvoering van het script al negeert.
Daarnaast kunt u opmerkingen invoegen die meerdere regels beslaan. Om dit te doen, markeert u het begin van een opmerking met een schuine streep gevolgd door een asterisk (/*) en het einde met een asterisk gevolgd door een schuine streep (*/).
<?php
/*
This is a multiple-line comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>Dergelijke opmerkingen worden niet geparseerd en verschijnen niet op de website.
Programmeurs gebruiken opmerkingen om de broncode van hun scripts te structureren, notities achter te laten voor latere bewerkingen of interne informatie toe te voegen aan de build, zoals de auteur of datum. Opmerkingen zijn optioneel en moeten spaarzaam worden gebruikt om de leesbaarheid van de broncode te waarborgen.
Reken met variabelen
In onze PHP-tutorial heb je al kennisgemaakt met variabelen, die voornamelijk stringwaarden bevatten. Laten we nu eens kijken naar variabelen die gehele getallen of drijvende-kommagetallen vertegenwoordigen. Wanneer variabelen numerieke waarden bevatten, kun je er in PHP berekeningen mee uitvoeren. Laten we beginnen met het optellen 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 vervolgens de variabele $result. Deze wordt gebruikt om de som van de variabelen $number1 en $number2 op te slaan. Voor deze bewerking gebruiken we de rekenkundige operator +(plus). Ten slotte geven we de som weer als tekst met behulp vande echo-taalconstructie. Merk op dat u geen aanhalingstekens hoeft te gebruiken wanneer u numerieke waarden toewijst aan variabelen.
Het volgende codevoorbeeld toont een selectie van wiskundige berekeningen die server-side met PHP kunnen worden uitgevoerd. De gebruikte PHP-operatoren komen grotendeels overeen met standaard wiskundige symbolen.
| Rekenkundige operator | Operatie | Resultaat |
|---|---|---|
| $getal1 + $getal2 | Optelling | Som van $getal1 en $getal2 |
| $getal1 - $getal2 | Aftrekken | Verschil tussen $getal1 en $getal2 |
| $getal1 *$getal2 | Vermenigvuldiging | Product van $getal1 en $getal2 |
| $getal1 / $getal2 | Delen | Quotiënt van $getal1 en $getal2 |
| $getal1 **$getal2 | Macht | $getal2-de macht van $getal1 |
<?php
$number1 = 10;
$number2 = 5;
$addition = $number1 + $number2; //addition
$subtraction = $number1 - $number2; //subtraction
$multiplication = $number1 * $number2; //multiplication
$division = $number1 / $number2; //division
$power = $number1 ** $number2; //power
?><?php
echo "Result of addition: " . $addition ."<br />";
echo "Result of subtraction: " . $subtraction . "<br />";
echo "Result of multiplication: " . $multiplication . "<br />";
echo "Result of division: " . $division . "<br />";
echo "10 to the 5th power (10^5): " . $power . "<br />";
echo "root of 81: " . sqrt(81) . "<br />";
?>
Voor complexe berekeningen kunnen verschillende rekenkundige bewerkingen in één script worden gecombineerd:
<?php
$number1 = 10;
$number2 = 5;
$result = 2 *$number1 + 5* $number2 - 3 * sqrt(81);
echo "Result: " . $result;
?>De PHP-interpreter bepaalt de waarden van de variabelen en berekent:
2 *10 + 5* 5 - 3 * √81 = 20 + 25 - 27 = 18
De functie sqrt() berekent de vierkantswortel van de parameter tussen haakjes. De klassieke rangorde van operatoren in de wiskunde is van toepassing: punt voor streepje. De instructie echo geeft het resultaat weer als een tekenreeks voor de webbrowser.
PHP evalueert ook eerst termen tussen haakjes. Deze keer gaan we werken met drijvende-kommagetallen:
<?php
$number1 = 2.5;
$number2 = 3.7;
$result = 2 *($number1 + 5)* ($number2 - 3) * sqrt(81);
echo "Result: " . $result;
?>
Net als alle gangbare programmeertalen biedt PHP operators waarmee numerieke waarden met de waarde 1 kunnen worden verhoogd of verlaagd. Er wordt onderscheid gemaakt tussen de pre-incrementoperator, de pre-decrementoperator, de post-incrementoperator en de post-decrementoperator.
| Bediening | Operator | Resultaat |
|---|---|---|
| Pre-increment | ++$number | De operator ++ verhoogt de waarde van de variabele $number. De waarde wordt met 1 verhoogd. Het resultaat wordt teruggegeven als de nieuwe waarde van $number. |
| Pre-decrement | –$number | De operator – verlaagt de waarde van de variabele $number. Dit verlaagt de waarde met 1. Het resultaat wordt teruggegeven als de nieuwe waarde van $number. |
| Post-increment | $number++ | De huidige waarde van $number wordt eerst geretourneerd en vervolgens met 1 verhoogd. |
| Post-decrement | $number– | De huidige waarde van $number wordt eerst geretourneerd en vervolgens met de waarde 1 verlaagd. |
Eerst laten we zien hoe je rekenkundige bewerkingen kunt uitvoeren met increment- en decrement-operatoren aan de hand van een voorbeeld met pre-increment. Het volgende script verhoogt de waarde van de variabele $number met 1, slaat de nieuwe waarde op in de variabele $result en geeft vervolgens de waarde weer als een string:
<?php
$number = 0;
$result = ++$number;
echo "Result: " . $result;
?>Als je de waarde 0 met 1 verhoogt, krijg je het resultaat 1.
Om de pre-decrement van de variabele $number te berekenen, gebruiken we dezelfde scripts, maar vervangen we de pre-increment operator (++) door de pre-decrement operator (–):
<?php
$number = 0;
$result = --$number;
echo "Result: " . $result;
?>Hier verlagen we de waarde 0 van de variabele $number en krijgen we het resultaat -1.
Een stijging voor en na de uitvoer (pre- vs. post-…) van een waarde kan worden aangetoond met het volgende script:
<?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. Bij pre-increment wordt de waarde van x verhoogd vóór de uitvoer in regel 3, terwijl bij post-increment deze wordt verhoogd na de uitvoer in regel 5.
Hoe gebruik je de superglobals $_GET en $_POST?
Je bent nu bekend met de basisprincipes van PHP. Je kunt werken met variabelen, samenvoegen en berekeningen uitvoeren. Vervolgens zullen we de cruciale rol van variabelen in scripting illustreren.
Een belangrijke functie van scripttalen is hun vermogen om gebruikersinvoer te evalueren en de waarden naar een ander script over te dragen. PHP maakt voor gegevensoverdracht gebruik van de superglobals $_GET en$_POST, vooraf gedefinieerde systeemvariabelen diein alle scopesbeschikbaar zijn. Als associatieve arrays (gegevensvelden) slaan*$_GET en $_POST* een reeks variabelen op in de vorm van strings in een variabele.
PHP-arrays kunnen worden vergeleken met een kast met meerdere lades. Elk van deze lades biedt ruimte voor het opslaan van gegevens. Om duidelijkheid te behouden over de inhoud van elke lade, geef je ze een variabele naam. Afhankelijk van het type array kan deze identificatie een index of een sleutel zijn. In geïndexeerde arrays wijs je een numerieke index toe aan elke lade, terwijl je in associatieve arrays de lades labelt met behulp van een op strings gebaseerde sleutel.
De superglobals $_GET en $_POST omvatten een verzameling variabelen die worden weergegeven als sleutels, waardoor toegang tot de bijbehorende waarden mogelijk is. We zullen hier dieper op ingaan wanneer we de superglobals $_GET en $_POST uitgebreid bekijken.
Gegevensoverdracht via $_GET
De superglobale $_GET vertegenwoordigt een reeks variabelen die via een URL aan een PHP-script worden doorgegeven.
Als je tijd doorbrengt op blogs,in onlinewinkels enop internetfora, zijn je misschien enkele vreemde URL’s opgevallen. Meestal zijn ze opgebouwd volgens het volgende schema:
http://hostname/ordner/filename.php?variablenname=variablevalue
Voor een blog zou het schema er als volgt uit kunnen zien:
http://www.example-blog.com/index.php?id=1
Het ontleden van een dergelijke URL is relatief eenvoudig. Op een webserver met het domein example-blog.com staat een bestand met de naam index.php. Dit bestand wordt gebruikt om dynamische webpagina’s te maken en bevat doorgaans HTML- en PHP-code, samen met verwijzingen naar externe sjabloonbestanden en stylesheets – in feite alle componenten die nodig zijn voor de weergave van webpagina’s.
De toevoeging van id=1 ineen URL is een veelgebruikte manier om te bepalen of een webpagina dynamisch is. U vindt dit achter het vraagteken (?) in een URL. Dit onderdeel staat bekend als een HTTP-queryreeks en bevat een variabele (id) en een waarde (1), die met elkaar zijn verbonden door een gelijkteken (=). URL-parameters van deze aard worden gebruikt om dynamische webpagina’s te genereren, database-inhoud op te halen en de juiste sjablonen te activeren.
Dynamische websites maken het mogelijk om inhoud en presentatie van elkaar te scheiden. Hoewel index.php de informatie over de structuur van een website bevat, moet deze nog steeds met inhoud worden gevuld. Deze wordt meestal opgeslagen in een database en kan worden geraadpleegd met behulp van parameters in de HTTP-queryreeks. In het voorbeeld geeft de URL van index.php de parameter id=1 door. Deze geeft aan welke inhoud uit de database moet worden gelezen en in index.php moet worden geladen. In de context van een blog kan dit de ID van een artikel zijn; voor een forum een bepaald bericht. Voor een online winkel kan dit een specifiek product zijn.
Als een URL meer dan één parameter bevat, worden deze met een ampersand (&) aan elkaar gekoppeld.
www.example-blog.com/index.php?page=article&id=1
Hieronder laten we u zien hoe u $_GET kunt gebruiken. Voor dit voorbeeld is het niet nodig om een database te gebruiken. In het volgende script gebruiken we de superglobale $_GET om de waarden van de variabelenfirstname en lastname uit een HTTP-queryreeks te lezen en deze naar de PHP-variabelen $variable1 en $variable2 te schrijven:
<?php
$variable1 = $_GET['firstname'];
$variable2 = $_GET['lastname'];
echo "Hello " . $variable1 . " " . $variable2 . "!";
?>Het script wordt aangeroepen via de volgende URL:
localhost/hello.php?firstname=John&lastname=Doe.
De parametersfirstname=John en lastname=Doe zijn doorgegeven. De uitvoer van de waarden gebeurt net als voorheen met behulp van de taalconstructie echo.
Een gegevensoverdracht via $_GET leidt er onvermijdelijk toe dat de overgedragen gegevens zichtbaar zijn in de adresbalk. Dit betekent dat doorgegeven parameters kunnen worden getraceerd. Het voordeel is dat variabelen kunnen worden opgeslagen in hyperlinks. Bovendien hebben gebruikers de mogelijkheid om URL’s, inclusief de HTTP-queryreeks, als bladwijzers in hun browser op te slaan.
Het feit dat GET-parameters echter in platte tekst in de URL worden weergegeven, maakt deze methode ongeschikt voor de overdracht van gevoelige gegevens, zoals gegevens die door online formulieren worden gegenereerd. Bovendien wordt de hoeveelheid gegevens die met $_GET kan worden doorgegeven, beperkt door de maximale lengte van URL’s.
Je kunt deze beperkingen omzeilen met de HTTP-methode POST. Gegevens die met deze methode worden doorgegeven, zijn te vinden in de superglobale variabele $_POST.
Gegevensoverdracht via $_POST
Terwijl in de GET-methode gegevens worden doorgegeven als een URL-parameter, vindt bij $_POST de gegevensoverdracht plaats in de body van een HTTP-verzoek. Hierdoor is het zelfs mogelijk om grote hoeveelheden gegevens van het ene script naar het andere door te geven.
Een belangrijk toepassingsgebied van de HTTP POST-methode is de overdracht van HTML-formuliergegevens. We zullen dit demonstreren aan de hand van het voorbeeld van een nieuwsbriefabonnement.
Maak hiervoor een nieuw PHP-bestand aan met de naam page1.php en kopieer het volgende codeblok:
<form method="post" action="page2.php" >
Please send your newsletter to: <br />
Your name: <input type="text" name="first name" /><br />
Your surname: <input type="text" name="lastname" /><br />
Your email address: <input type="text" name="email" /><br />
<input type="submit" value="Send form" />
</form>Het HTML-element <form> wordt gebruikt om formulieren te maken. De starttag bevat twee attributen:method en action. Met het attribuut method definieert u de overdrachtsmethode, in dit geval HTTP-POST. In het attribuut action slaat u de URL op van een script dat alle gegevens ontvangt die via de volgende invoervelden zijn ingevoerd. Het voorbeeld toont een HTML-formulier met drie invoerelementen (input type=“text”) en een verzendknop (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 om de formuliergegevens te evalueren, dat de ingediende waarden opslaat als PHP-variabelen en deze in tekstvorm weergeeft. Maak hiervoor een bestand page2.php aan en voeg de volgende programmacode toe:
<?php
$name = $_POST["name"];
$surname = $_POST["lastname"];
$email = $_POST["email"];
echo "Hello " . name . " " . $lastname . ", <br />
You have registered with the following e-mail address:" . $email . ".";
?>Sla de twee PHP-bestanden op in de map htdocs van uw testserver en roep page1.php op vanuit de volgende URL in uw webbrowser: http://localhost/page1.php. Uw browser toont u nu de interactieve webinterface van uw HTML-formulier.
Voer uw inloggegevens in en druk op de verzendknop om variabelen van het ene script naar het andere over te brengen. Zodra u de invoer op pagina1.php bevestigt, wordt u onmiddellijk doorgestuurd naar pagina2.php. Het browservenster toont het resultaat van de uitvoering van het script op basis van de verzonden gegevens.
Gebruikersinvoer die via de invoervelden van pagina1.php wordt vastgelegd, wordt door pagina2.php opgehaald via:
$_POST["input field name"]
De regel $firstname = $_POST[“firstname”] haalt de invoer in het invoerveld firstname op en slaat deze op in de variabele $firstname. De variabele $firstname kan op zijn beurt worden uitgevoerd als een tekenreeks met behulp van echo.
Hoe PHP-vergelijkingsoperatoren en de IF-constructie te gebruiken
Tot nu toe hebben we variabelen gedefinieerd, ze van het ene script naar het andere doorgegeven en ze als strings uitgevoerd. In de volgende stap leer je hoe je de uitvoering van codefragmenten aan bepaalde voorwaarden kunt koppelen.
Met de taalconstructie if kunt u scripts schrijven op een manier dat instructies alleen van kracht worden wanneer aan een door u gedefinieerde voorwaarde is voldaan, bijvoorbeeld het invoeren van het juiste wachtwoord.
Voorwaarden worden in PHP gedefinieerd volgens het volgende basiskader:
<?php
if(expression)
{
statement;
}
?>Dit luidt als volgt: Als aan de voorwaarde zoals beschreven in de uitdrukking wordt voldaan, wordt de instructie uitgevoerd. Aan een voorwaarde wordt altijd voldaan als de if-constructie het resultaat TRUE (waar) retourneert. Anders wordt deze als FALSE (onwaar) beschouwd. In dat geval wordt de instructie overgeslagen.
Gewoonlijk controleert de if-constructie of de waarde van een variabele overeenkomt met wat in de voorwaarde is gedefinieerd. Deze controlestructuur wordt meestal gerealiseerd op basis van vergelijkingsoperatoren.
Vergelijkingsoperatoren
Vergelijkingsoperatoren worden gebruikt bij het formuleren van voorwaarden om twee argumenten in een logische relatie te plaatsen die kan worden geëvalueerd als waar (TRUE) of onwaar (FALSE). Wanneer vergelijkingsoperatoren worden gebruikt in PHP-controlestructuren, worden ze toegepast op twee variabelen in de uitdrukking van een if-constructie:
if ($a == $b)
{
statement;
}In termen van taal is de controlestructuur als volgt: als variabele $a gelijk is aan variabele $b, dan worden de instructies die in de instructie zijn gedefinieerd, uitgevoerd.
De PHP-vergelijkingsoperatoren zijn gebaseerd op de programmeertaal C en hun notatie verschilt aanzienlijk van klassieke wiskundige symbolen. Een overzicht vindt u in de onderstaande tabel.
| Vergelijkingsoperator | Beschrijving | Voorwaarde |
|---|---|---|
| == | gelijk | Aan de voorwaarde wordt voldaan als $a en $b dezelfde waarde hebben. |
| === | is identiek | Aan de voorwaarde wordt voldaan als $a en $b dezelfde waarde hebben en tot hetzelfde gegevenstype behoren. Dit kan worden geïllustreerd met een voorbeeld waarin een geheel getal (1) wordt vergeleken met een tekenreeks (“1”): 1 == “1” //WAAR 1 === “1” //ONWAAR Voor voorwaarden waarbij twee variabelen gelijk moeten zijn, kunt u het beste altijd de relationele operator === (is identiek) gebruiken. |
| != | is ongelijk | Aan de voorwaarde wordt voldaan als $a en $b ongelijke waarden hebben. |
| !== | niet identiek | Aan de voorwaarde wordt voldaan als $a en $b ongelijke waarden hebben of tot verschillende gegevenstypen behoren. |
| `< * | is kleiner dan | Aan de voorwaarde wordt voldaan als waarde* $a kleiner is dan waarde $b*. |
| *>` | is groter dan | Aan de voorwaarde wordt voldaan als de waarde van* $a groter is dan de waarde van $b*. |
| <= | is kleiner dan of gelijk aan | De voorwaarde is vervuld als de waarde van $a kleiner is dan de waarde van $b of als $a en $b dezelfde waarde hebben. |
| >= | is groter dan of gelijk aan | Aan de voorwaarde wordt voldaan als de waarde van $a groter is dan de waarde van $b of als $a en $b dezelfde waarde hebben. |
Het volgende script maakt deze controlestructuur duidelijk. Er worden twee gehele getallen vergeleken. De vergelijkingsoperator < (is kleiner) wordt gebruikt:
<?php
$number1 = 10;
$number2 = 20;
if($number1 < $number2) {
echo "The condition is fulfilled";
}We definiëren de variabelen $number1 en $number2 en kennen ze de waarden10 en 20 toe. Vervolgens stellen we een voorwaarde in: als $number1 kleiner is dan $number2, moet de string in de echo-instructie worden weergegeven.
Het resultaat van de uitvoering van het script bevat het antwoord: 10 is kleiner dan 20. De if-constructie retourneert het resultaat TRUE. Aan de voorwaarde is voldaan.
Om statements te definiëren die worden uitgevoerd als niet aan een voorwaarde wordt voldaan, voeg je de taalconstructie else toe aan de if-statement om een if-else-statement in PHP te vormen:
<?php
if(condition a)
{
statement b;
}
else
{
statement c
}
?>Dit script controleert of voorwaarde a TRUE of FALSE oplevert. Als aan voorwaarde a wordt voldaan (TRUE), wordt instructie b uitgevoerd. Als niet aan voorwaarde a wordt voldaan (FALSE), wordt instructie b overgeslagen en wordt in plaats daarvan instructie c uitgevoerd.
Laten we ons script uitbreiden met de else -constructie en de vergelijkingsoperator < (is kleiner) vervangen door == (is gelijk):
<?php
$number1 = 10;
$number2 = 20;
if($number1 == $number2)
{
echo "The condition is fulfilled";
}
else
{
echo "The condition is not fulfilled";
}
?>Deze keer retourneert de if-constructie FALSE. De waarde van de variabele $number1 is niet gelijk aan de waarde van $number2. Aan de voorwaarde is niet voldaan. Daarom wordt de instructie onder if niet uitgevoerd, maar wel die onder else.
Om de uitvoering van een codefragment te koppelen aan twee gelijke waarden, wordt in PHP een dubbel gelijkheidsteken (==) gebruikt. Een enkel gelijkheidsteken (=) wordt gebruikt om waarden aan variabelen toe te wijzen.
Je kunt voorwaarden ontkrachten door een uitroepteken (!) voor een uitdrukking te plaatsen.
<?php
$number1 = 10;
$number2 = 20;
if ($number1 == $number2)
{
echo "The numbers are the same.";
}
if (!($number1 == $number2))
{
echo "The numbers are not equal.";
}
?>Dit voorbeeld benadrukt de voorwaarde $number1 == $number2 en de negatie ervan. !($number1 == $number2) is gelijk aan ($number1 != $number2).
Een praktische toepassing vanifandelse is het opvragen van een wachtwoord op basis van een HTML-formulier. We kunnen dit simuleren met behulp van onze PHP-bestanden page1.php en page2.php.
Open pagina1.php en plak de volgende code:
<form action="page2.php" method="post">
Please enter your password: <input type="password" name="password" />
<input type="submit" value="send" />
</form>De structuur komt overeen met een eerder aangemaakt formulier. Deze keer is echter één invoerveld voldoende: de wachtwoordquery. Net als voorheen wordt de gebruikersinvoer doorgegeven aan het script page2.php.
We kunnen dit aanpassen met behulp van de volgende code, zodat het ingevoerde wachtwoord wordt vergeleken met een opgeslagen wachtwoord:
<?php
$password = $_POST["password"];
if($password=="qwertz123")
{
echo "The password was correct";
}
else
{
echo "The password was incorrect";
}
?>De code kan als volgt worden uitgelegd: in eerste instantie wijzen we op regel 2 een waarde toe aan de variabele $password, die we ophalen met behulp van de HTTP POST-methode. Vervolgens definiëren we de volgende controlestructuur: de if-constructie in regel 3 moet controleren of de waarde van de variabele $password overeenkomt met de tekenreeks qwertz123. Als dit het geval is, wordt de tekenreeks Het wachtwoord was correct weergegeven. Als if het resultaat FALSE retourneert, wordt else gebruikt in regel 7 en wordt de tekenreeks Het wachtwoord was onjuist weergegeven.
Nu roepen we het script page1.php op via de URL http://localhost/page1.php.
De browser toont de webweergave van ons HTML-wachtwoordaanvraagformulier. We voeren het wachtwoord quertz123 in dat is gedefinieerd in script page2.php en klikken vervolgens op de knop Verzenden.
De webbrowser leidt ons automatisch door naar page2.php, terwijl de if-controlestructuur onze invoer vergelijkt met het opgeslagen wachtwoord. Het resultaat is “qwertz123 == qwertz123 is *TRUE”*en vervolgens wordt de string Het wachtwoord was correct weergegeven.
Test het zelf om te zien wat er gebeurt als je een ander wachtwoord in het invoerveld typt.
Logische operatoren
Voorwaarden die u definieert met behulp van vergelijkingsoperatoren in de uitdrukking van de if- constructie kunnen indien nodig worden gecombineerd met andere voorwaarden in dezelfde uitdrukking. PHP maakt gebruik van de logische operatorenAND en OR.
| Close Bond | Zwakke band | Beschrijving | ||
|---|---|---|---|---|
| && | EN | Beide voorwaarden die verband houden met de operator moeten WAAR zijn. | ||
| *\ | \ | * | OR | Slechts één van de twee voorwaarden die aan de operator zijn gekoppeld, moet WAAR zijn. |
Om voorwaarden te combineren, kunt u in PHP nauw verbonden en zwak verbonden logische operatoren gebruiken. In de praktijk levert het gebruik van een van beide spellingen alleen geen merkbaar verschil op. Als u beide spellingen combineert, zult u merken dat OR en || sterker gebonden zijn dan AND en OR. Ook AND en&& zijn sterker gebonden dan OR en ||. Dit is vergelijkbaar met de rangorde van operatoren die bekend is uit de wiskunde (bijvoorbeeld punt voor streepje: * is sterker gebonden dan +).
De wachtwoordquery biedt een praktisch voorbeeld. Doorgaans bestaan inloggegevens uit een geheim wachtwoord en een gebruikersnaam. Het inloggen is alleen succesvol als beide gegevens overeenkomen met de gegevens die in het systeem zijn opgeslagen.
Nu openen we ons wachtwoordqueryformulier opnieuw in Page1.php en voegen we 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="Submit" />
</shape>In de volgende stap moeten we de controlestructuur van de if-constructie aanpassen. We gebruiken de logische operator AND om de voorwaarde voor de wachtwoordquery te koppelen aan een voorwaarde voor de gebruikersnaamquery.
<?php
$username = $_POST["username"];
$password = $_POST["password"];
if($username=="John Doe" AND $password=="qwertz123")
{
echo "Welcome to the internal area" . $username . "!";
}
else
{
echo "Access failed";
}
?>In ons script page2.php worden de waarden voorusername en password opgehaald en opgeslagen in de variabelen $username en $password. De uitdrukking binnen de if-constructie bevat nu twee voorwaarden die met elkaar zijn verbonden door de logische operator AND. Aan beide voorwaarden moet worden voldaan (username==“JohnDoe” en $password==“qwertz123”**)om ifhet resultaat TRUE te laten retourneren.
Terwijl we de gebruikersnaam uit het invoerveld username ophalen, kunnen we deze direct in de tekstuele uitvoer gebruiken met behulp van de echo-instructie. Welcome to the internal area wordt gevolgd door de waarde in $username. Als aan een van beide voorwaarden niet wordt voldaan, is de tekstuele uitvoer: Access failed.
Logische operatoren kunnen op elke manier worden gecombineerd. Houd er rekening mee dat AND een hogere operatorprioriteit heeft dan OR. Net als bij wiskundige vergelijkingen kunt u in PHP haakjes gebruiken om de prioriteit aan te geven.
Hoe loops te gebruiken (while, for)
Soms moet een script een bepaald deel van de code meerdere keren doorlopen voordat de rest van de programmacode wordt uitgevoerd. Programmeertalen gebruiken hiervoor het concept van loops. Er zijn drie soorten loops in PHP:
- while -lussen
- do-while -lussen
- for -lussen
while -lussen
De while-lus is het eenvoudigste type lus in PHP. Hier is de basisstructuur:
while (condition)
{
loop step and other instructions
}De while-lus vertelt PHP om substatements uit te voeren zolang aan de while-voorwaarde wordt voldaan. Om dit te doen, controleert de PHP-interpreter de voorwaarde aan het begin van elke lusdoorloop. De uitvoering van de ondergeschikte code wordt alleen gestopt wanneer niet langer aan de while-voorwaarde wordt voldaan.
Dit principe kan worden geïllustreerd met een eenvoudig telscript:
<?php
$number = 1;
while ($number <= 10) {
echo $number++ . "<br />";
}
?>Het concept van incrementeren werd geïntroduceerd in het gedeelte Reken met variabelen van deze tutorial. In het volgende script bouwen we voort op dit concept, maar met een twist. Deze keer gebruiken we een post-increment operator. Dit verhoogt de waarde van de integer variabele $number met 1 na elke iteratie van de lus, onmiddellijk na de echo tekstuitvoer. We stellen de voorwaarde voor de while-lus als volgt in: $number is groter dan of gelijk aan 10. Bijgevolg wordt de echo-instructie herhaaldelijk uitgevoerd totdat $number een waarde van 10 overschrijdt.
Het resultaat van de uitvoering van het script is een tekenreeks die de waarde van de variabele $number voor elke lusdoorloop afdrukt voordat deze wordt verhoogd. Als gevolg hiervan telt het script van 1 tot 10 en stopt het met het uitvoeren van de code zodra niet langer aan de while-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 lus wordt gecontroleerd, maar alleen aan het einde. Het basisschema van een do-while-lus is als volgt:
do {
loop step and other instructions
}
while (condition)Geprogrammeerd als een do-while-lus zou het voorgaande script er als volgt uitzien:
<?php
$number = 1;
do {
echo $number++ . "<br />";
}
while ($number <= 10);
?>In dit geval blijft het resultaat hetzelfde. Het bijzondere aan de do-while-lus is dat deze minstens één keer wordt doorlopen, zelfs als in geen enkele lusdoorloop aan de voorwaarde wordt voldaan.
for -lussen
Over het algemeen heeft de for-lus in een PHP-script dezelfde functie als de while-lus. In tegenstelling tot de while-lus worden de startwaarde, voorwaarde en instructie echter op één regel geschreven in plaats van verspreid over drie of meer regels. De basisstructuur van de for-lus is:
for (start value; condition; loop step)
instructionsHet bovenstaande voorbeeld zou compacter kunnen worden geschreven als een for-lus:
<?php
for($number = 1; $number <= 10; $number++) {
echo $number . "<br /> ";
}
?>Eerst wordt de waarde 1 gedefinieerd voor $number. Vervolgens controleert PHP of aan de voorwaarde $number <= 1 is voldaan. Als dit het geval is, wordt de lus voortgezet en worden de instructies onder de lus uitgevoerd (hier is de instructie echo). Zodra dit is gebeurd, worden de stappen van de lus uitgevoerd. In deze context is de keuze tussen pre- of post-increment niet relevant, omdat deze stap altijd vóór de uitvoer plaatsvindt. Zodra de lusstap is voltooid, begint de volgende iteratie van de lus.
In een for-lus worden de seed, voorwaarde en lusstap beschouwd als optionele componenten. In theorie zijn zelfs lege lussen mogelijk. Dergelijke lussen zouden echter overbodig zijn.
Het is in principe aan jou om te beslissen of je je PHP-scripts met een for- of een while-lus schrijft. Er is echter een argument om voor for -lussen te kiezen: wanneer for-lussen worden gebruikt, heb je een beter overzicht van de frameworkgegevens van de lus. Dit voorkomt het risico dat je per ongeluk een oneindige lus schrijft die blijft draaien totdat het geheugen van de interpreter vol is. Verwijzend naar het vorige voorbeeld kan dit gebeuren wanneer je vergeet de waarde van de variabele $number te verhogen.
Als de lus echter minstens één keer moet worden doorlopen, ongeacht de voorwaarde, dan is de do-while-lus de juiste keuze.
breakandcontinue -instructies
De uitvoering van een while-, do-while- of for-lus kan worden beïnvloed door debreak- en continue- instructies. Gebruik break om de stroom van een lus op elk moment te onderbreken en door te gaan met het overslaan van een lusdoorloop. Beide instructies zijn gebonden aan een voorwaarde met behulp van if. Het volgende voorbeeld toont ons telscript met een break:
<?php
for ($number = 1; $number <= 10; $number++) {
if ($number == 5) {
echo "If it is 5, we abort the script!";
break;
}
echo $number . "<br /> ";
}
?>In de for-lus hebben we bepaald dat de waarde van de variabele $number in elke lusronde met de waarde 1 moet worden verhoogd, beginnend bij 1, totdat de variabele de waarde 10 heeft bereikt. We kunnen deze lus voortijdig stoppen met break zodra $number de waarde 5 heeft bereikt. De taalconstructie echo geeft alleen de getallen 1 tot en met 4 weer.
Om de uitvoer van de vijfde ronde over te slaan, maar de hele lus niet te stoppen, vervangen we de break-instructie door continue:
<?php
for ($number=1; $number <= 10; $number++) {
if ($number == 5) {
echo "Let's skip the 5!<br />";
continue;
}
echo $number . "<br /> ";
}
?>In plaats van het cijfer 5 geeft PHP de tekstreeks We slaan nummer 5 over! weer, die is gedefinieerd onder if.
Hoe bestandsbewerkingen uitvoeren
Dynamische webcontent is opgebouwd volgens het principe van het scheiden van inhoud en presentatie. Om dit te bereiken bieden scripttalen zoals PHP een breed scala aan functionaliteiten die de naadloze integratie van content uit externe databronnen in centrale sjabloonbestanden vergemakkelijken. In de praktijk zijn deze databronnen meestal databases die worden beheerd met behulp van beheersystemen zoals MySQL. Hoe dit werkt, kunt u ontdekken in onze MySQL-tutorial.
Het is ook mogelijk om gegevens uit bestanden op te nemen. Hieronder laten we u zien hoe u bestanden als een string in een PHP-script kunt lezen en de tekstuitvoer van uw script in bestanden kunt opslaan.
Bestanden lezen
Om de inhoud van een bestand te lezen, beschikt PHP over verschillende functies. Hiervan zijn file() en file_get_contents() bijzonder geschikt voor de betreffende taak. Terwijl de functie file_get_contents() de volledige inhoud van een bestand in een string leest, slaat de functie file() de inhoud op als een array. Elk element van de array komt overeen met een regel van het bestand. Met file() is het eenvoudiger om elke regel afzonderlijk weer te geven.
We demonstreren de PHP-bestandsbewerkingen op het tekstbestand example.txt, dat we in de map htdocs van onze testserver plaatsen. Het bestand bevat vier regels dummytekst:
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.
Eerst moeten we het hele bestand als een string lezen. Hiervoor moeten we de naam van het betreffende bestand als parameter toewijzen aan de functie file_get_contents():
file_get_contents('example.txt')
Nu hebben we de mogelijkheid om met de gelezen string te werken. We kunnen deze bijvoorbeeld toewijzen aan een variabele en deze als tekst weergeven in de webbrowser:
<?php
$example = file_get_contents('example.txt');
echo $example;
?>
In de browserweergave zien we dat de tekstreeks zonder alinea’s wordt weergegeven. De regeleinden van het oorspronkelijke bestand zijn niet zichtbaar. Dat komt omdat de webbrowser de tekstuitvoer van het script interpreteert als HTML-code. Regeleinden die in tekstverwerkers zijn gedefinieerd, gaan verloren.
Om de oorspronkelijke structuur te behouden, heb je een aantal opties. Je kunt de HTML-code voor de regeleinde (br) handmatig toevoegen aan het bronbestand met behulp van zoeken en vervangen, een <pre> rond de inhoud van het bestand plaatsen, de CSS-eigenschap white-space: pre -wrap instellen, of de functie nl2br() gebruiken om PHP te laten weten dat het regeleinden (nieuwe regels) automatisch moet omzetten naar HTML-regeleinden (breaks). Hier is de code:
<?php
$example = file_get_contents('example.txt');
echo nl2br($example);
?>Als de echo-taal constructie wordt gebruikt in combinatie met nl2br(), voegt PHP een HTML-regeleinde in voor elke nieuwe regel.
Om de regels van een bestand afzonderlijk weer te geven, kunt u de functie file() gebruiken. Deze leest een bestand, nummert alle regels beginnend met het getal 0 en slaat hun inhoud op als elementen van een array. Als we dit toepassen op ons voorbeeld, krijgen we het volgende resultaat:
[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 betreffende inhoud met echo weer te geven, hoeft u alleen maar het gewenste regelnummer op te geven. Het volgende script geeft bijvoorbeeld alleen de eerste regel van het bestand example.txt weer in de browser:
<?php
$example = file("example.txt");
echo $example [0];
?>
Bestanden schrijven
PHP gaat verder dan alleen het lezen van bestanden, omdat je er ook moeiteloos bestanden mee kunt lezen, maken en wijzigen.
Het gebruik van de functie file_put_contents() is een goed voorbeeld. Er zijn slechts twee parameters nodig: de naam van het doelbestand en de gegevens, die een tekenreeks of een array kunnen zijn. In het onderstaande script wordt een nieuw bestand met de naam test.txt aangemaakt, dat de tekenreeks This is a test! bevat. Door \r\n toe te voegen, wordt een regeleinde in het bestand gegarandeerd.
<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt has been created!";
?>
Aangezien file_put_contents geen uitvoer voor de browser geeft, voegen we een echo-instructie toe die ons vertelt welke actie wordt uitgevoerd.
Als er al een bestand met dezelfde naam in de doelmap staat, wordt dit overschreven. U kunt dit voorkomen door de parameter FILE_APPEND in te stellen:
<?php
file_put_contents("test.txt","The test was successful! \r\n", FILE_APPEND);
echo "test.txt has been updated!";
?>Door file_put_contents() te gebruiken met de parameter FILE_APPEND, wordt nieuwe inhoud toegevoegd aan bestaande inhoud.
Wat PHP naar het doelbestand schrijft, hoeft niet noodzakelijkerwijs in het script te worden gedefinieerd. Als alternatief kunt u inhoud van het ene bestand naar het andere overbrengen. Het volgende script leest de inhoud van example.txt en voegt deze in het bestand test.txt in:
<?php
$example = file_get_contents("example.txt");
file_put_contents("test.txt", $example, FILE_APPEND);
echo "test.txt has been updated!";
?>
