# Aan de slag met PHP – Een tutorial voor beginners
[PHP](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/wat-is-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](https://www.apachefriends.org/index.html "Download page of Apache 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
```
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/simple-php-code-in-notepad-plus-plus.png) A text editor like Notepad++ supports programming with syntax highlighting. 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:*?>.
Definitie 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 `
```
De openingstag `` 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:
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/hello-php-language-construct-echo.png) The language construct \*echo\* instructs the web server to output the string \*Hello World!\* 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
Hello World!
This is my first PHP page.
';
?>
```
Wanneer **het script** in de webbrowser wordt aangeroepen, wordt het **resultaat van de uitvoering** als volgt weergegeven.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/script-execution-result-html-tags-hello-world.png) If the result of the script execution contains HTML tags, they’ll automatically be interpreted by the web browser. De tekst *Hello World!*, die tussen `` 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:
```php
$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
Hello World!
This dynamic web page was created by $author.
";
?>
```
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:
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/hello-world-html-tags-dynamic-text-creation-johndoe.png) As a result of script execution, the variable $author was assigned the value John Doe 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.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/dynamic-text-creation-hello-world-max-mustermann.png) For the variable $author, the value Max Mustermann is used. 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
Hello World!
This dynamic web page was created by $author.
";
$author = "Max Mustermann";
echo " Supported by $author.
";
?>
```
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/dynamic-text-creation-overwriting-variables-jd-mm.png) The value John Doe is overwritten with the value Max Mustermann 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
```
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
Hello World!
This dynamic web page was created by $author.
';
?>
```
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/hello-world-dynamic-content-simple-quote-marks.png) Single quotes result in plain text output. Variables are not interpreted. 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
```
Foutmeldingen bevatten in de meeste gevallen informatie over waar een fout is opgetreden, wat belangrijke informatie oplevert voor het verhelpen ervan.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-web-browser-parse-error.png) An error message indicates syntactical errors in the program code. 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
```
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-content-backslash-as-marking-symbol.png) If characters are masked with a backslash, they are stripped of their function in the PHP syntax. Het combineren van enkele en dubbele aanhalingstekens is ook een haalbare aanpak:
```php
```
Maar niet deze spelling:
```php
```
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
Hello World!
This dynamic web page was created by $author1 and $author2.
";
?>
```
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.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/text-output-with-two-variables-php.png) Variables in the string are only accepted by PHP if the script does not contain functions. 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
Hello World!
This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.
';
?>
```
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-concatenation-of-strings-and-vars.png) Concatenation operators connect strings and variables 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
```
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.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-extending-string-variable-via-operator.png) The string Hello has been extended to Hello World ### 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:
``
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
My first PHP page
Hello World
What is the current time and date?
hash_69a0f4c4a2b7a04cf6b25db6ba6adf3209076ea3
```
Voeg nu een PHP-script toe aan uw HTML-document. Zorg ervoor dat alle code binnen de PHP-tags staat.
```html
My first PHP page
Hello World
What is the current time and date?
Your current time and date is:
.
hash_69a0f4c4a2b7a04cf6b25db6ba6adf3209076ea3
```
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.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-integration-in-html-date-and-time.png) The HTML document contains an integrated PHP script that outputs the current date including time. ### 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
Hello World!
This is my first PHP page.
';
//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.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-single-line-comment.png) Lines marked as comments are not visible in the output. 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
Hello World!
This is my first PHP page.
';
?>
```
Dergelijke opmerkingen worden niet geparseerd en verschijnen niet op de website.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-multi-line-comment.png) The multiline comment is not visible in the output. 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
```
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 van*de echo-taalconstructie*. Merk op dat u geen aanhalingstekens hoeft te gebruiken wanneer u numerieke waarden toewijst aan variabelen.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-simple-integer-addition.png) The result of the addition is output as text in the web browser. 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
```
```php
";
echo "Result of subtraction: " . $subtraction . "
";
echo "Result of multiplication: " . $multiplication . "
";
echo "Result of division: " . $division . "
";
echo "10 to the 5th power (10^5): " . $power . "
";
echo "root of 81: " . sqrt(81) . "
";
?>
```
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-various-arithmetic-operations.png) Arithmetic operations at a glance Voor complexe berekeningen kunnen verschillende rekenkundige bewerkingen in één script worden gecombineerd:
```php
```
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.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-complex-calculation-two-variables.png) PHP follows the dot-before-dash rule. PHP evalueert ook eerst **termen tussen haakjes**. Deze keer gaan we werken met drijvende-kommagetallen:
```php
```
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-float-operation-with-brackets.png) PHP calculation with the result 94.5 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
```
Als je de waarde 0 met 1 verhoogt, krijg je het resultaat 1.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-operations-increment-plus-plus.png) The ++ operator increments 0 by the value 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
```
Hier verlagen we de waarde 0 van de variabele *$number* en krijgen we het resultaat -1.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-operations-decrement-minus-minus.png) The operator -- decrements the number 0 by the value 1 Een stijging voor en na de uitvoer (pre- vs. post-…) van een waarde kan worden aangetoond met het volgende script:
```php
result: ' . ++$x;
echo '
x has the value ' . $x;
echo 'result: ' . $x++;
echo '
x has the value ' . $x, '
';
?>
```
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.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-script-pre-vs-post.png) Pre- and post-incrementations in comparison ## 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 die**in alle scopes**beschikbaar 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** en**op 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 in*een 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 variabelen*firstname en lastname* uit een HTTP-queryreeks te lezen en deze naar de PHP-variabelen *$variable1 en $variable2* te schrijven:
```php
```
Het script wordt aangeroepen via de volgende URL:
`localhost/hello.php?firstname=John&lastname=Doe`.
De parameters*firstname=John en lastname=Doe* zijn doorgegeven. De uitvoer van de waarden gebeurt net als voorheen met behulp van de taalconstructie *echo*.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-data-transmission-via-get.png) The URL parameters pass the variable value pairs firstname=John and lastname=Doe to the PHP script. 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:
```php
```
Het HTML-element `
```
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
```
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`.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-password-entry-page-html.png) The HTML form prompts you to enter a password. 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**.
[](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/php-password-entry-correct.png) The script confirms that the password that was entered is correct. 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 operatoren**AND 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:
```php