PHP Beginners handleiding

Welkom bij deze PHP beginners handleiding waarin ik de basis van het programmeren in PHP zal uitleggen. Met deze handleiding zal ik proberen om je, aan de hand van vele voorbeelden, een degelijke basiskennis van het gebruik van PHP te geven. Met deze basiskennis kun je daarna zelf aan de slag en je storten op het programmeren van mooie applicaties en websites.

Wat is PHP?
PHP is een programmeertaal die voornamelijk gebruikt wordt voor het bouwen van dynamische websites. De eerste versie van deze scripttaal verscheen in 1995 en de afkorting stond toen voor 'Personal Home Page tool'. Tegenwoordig wordt deze afkorting eigenlijk niet meer gebruikt en zien we enkel nog de omschrijving 'PHP: Hypertext Preprocessor' als we zouden zoeken naar de betekenis van PHP.

Deze omschrijving is dan ook een stuk toepasselijker aangezien PHP in veel meer toepassingen gebruikt wordt dan enkel persoonlijke webpaginas. De term 'hypertext preprocessor' geeft aan waar PHP in de meeste gevallen voor gebruikt wordt: het verwerken van gegevens tot hypertext (HTML). PHP is een server-side scripttaal en wordt door de webserver uitgevoerd, in tegenstelling tot bijvoorbeeld HTML, CSS en Javascript, talen die door de browser geïnterpreteerd of uitgevoerd worden. Dit betekent dus ook dat PHP uitgevoerd wordt vóórdat er iets door de browser gedaan wordt, hetgeen ons in staat stelt om dynamisch HTML te genereren en naar de browser te sturen.

Voorkennis
Bij het lezen van deze tutorial is het makkelijke als je enige kennis van het bouwen van websites en het gebruik van HTML hebt. Zoals je merkt zijn er nu al wat termen gevallen, die je wellicht bekend voorkomen. Om deze tutorial te kunnen volgen is het bezitten van deze kennis echter niet noodzakelijk.

Wat heb ik nodig?
Zoals gezegd is PHP een server-side scripttaal. Je moet dus beschikking hebben over een webserver met PHP ondersteuning. Veel gratis webhosts ondersteunen geen PHP en ook op de webruimte die je van je provider krijgt, is PHP vaak niet beschikbaar.

Ikzelf raad aan om een webserver op je eigen PC te installeren en deze server te gebruiken om je PHP scripts te testen. Een compleet pakket voor Windows met daarin een webserver, PHP en een databaseserver is WAMP. Dit pakket is zeer eenvoudig te installeren en bevat alles wat je in deze tutorial nodig zult hebben.

Tenslotte heb je een goede editor nodig. Omdat het schrijven van PHP nogal nauw luistert en er dus eenvoudig foutjes in je script kunnen sluipen, is het gebruik van een goede editor noodzakelijk om deze foutjes snel op te kunnen sporen. Een voorbeeld van een goede gratis editor is Eclipse PDT.

Zo, nu weten we een klein beetje wat PHP is en doet. Laten we snel beginnen met het eigenlijke werk...

Opmerking: op PHPHulp heb ik helaas niet heel veel opties met betrekking tot de layout. Een duidelijkere versie van deze tutorial kun je hier vinden: PHP Beginners handleiding

Changelog:
03-01-2008: Het hoofdstuk over formulieren een kleine makeover gegeven, naar aanleiding van de opmerking van t_vercetti. Thnx!

19-01-2008: Stukje over inschakelen van display_errors instelling dmv .htaccess toegevoegd aan hoofdstuk over debuggen.

Zoals we in de inleiding hebben kunnen lezen, is PHP een server-side scripttaal. Dit houdt in dat de PHP code door de server verwerkt (geparsed) moet worden waarna een eventuele uitkomst naar de browser gestuurd wordt. Standaard is de webserver zo ingesteld dat bestanden, die eindigen op de extensie .php, door de server als PHP script geparsed worden.

Zo'n .php bestand hoeft niet alleen PHP code te bevatten, er kan net zo goed HTML, CSS en Javascript in voorkomen. We zullen de server dus duidelijk moeten maken welke delen PHP code bevatten en welke delen dus door de server verwerkt moeten worden. Dit kunnen we aangeven met behulp van de php tags:

<?php

?>

Alle code die we tussen deze twee tags plaatsen, wordt door de server geparsed en tussen deze twee tags is het dus mogelijk om op een of andere manier HTML te genereren. Het grote voordeel hiervan is dat we een mogelijkheid krijgen om op een dynamische manier HTML code uit te spugen. Dat de code geparsed wordt door de server en deze alleen HTML uitspuugt, is tevens de reden dat je nooit PHP code in de bron van een pagina tegen zult komen. Deze is immers allemaal door de server omgezet.

Ons eerste PHP bestand
Laten we eens kijken naar een voorbeeld van een PHP bestand:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Mijn eerste php script!</title>
</head>

<body>
<?php
echo 'Hello World!';
?>
</body>
</html>

Bovenstaande code is een voorbeeld van hoe een webpagina opgebouwd wordt. Zoals je wellicht al wist bestaat een HTML pagina altijd uit <html>, <head> en <body> tags. In de <body> tag hebben we nu een stukje PHP staan, dat de tekst 'Hello World!' op het scherm zet.

Kopieer de code naar een leeg document in je editor en sla het op als bijvoorbeeld index.php. Open de pagina vervolgens in je webbrowser en je zult het volgende resultaat zien:

Hello World!

In het voorbeeld zien we dat we 'echo' in PHP kunnen gebruiken om HTML naar de browser te sturen. Alles wat we tussen de <body> tags in de HTML code echoën, zal dan ook op het scherm weergegeven worden. De gebruikte HTML code in de pagina zorgt ervoor dat de browser begrijpt wat hij weer moet geven. Het volgende voorbeeld waarin enkel HTML gebruikt wordt, zal precies dezelfde output geven:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Mijn eerste php script!</title>
</head>

<body>
Hello World!
</body>
</html>

Misschien zul je je nu afvragen wat nou het nut van PHP is, maar dat zal later in deze tutorial blijken. Even geduld nog.

Dit waren de eerste maar tevens ook de laatste voorbeelden waarin zoveel HTML code zal gebruiken. Om de voorbeelden duidelijk en overzichtelijk te houden, zal ik dat vanaf nu enkel de PHP code gebruiken. Vergeet echter niet dat in de uiteindelijke webpagina de HTML wel aanwezig moet zijn!

Alternatieve open- en sluittags
In plaats van de uitgebreide [ignore]<?php en ?>[/ignore] tags, zouden we ook [ignore]<? en ?>[/ignore] kunnen gebruiken. Het gebruik van deze zogenaamde 'shorttags' is echter niet aan te raden omdat deze instelling lang niet op alle servers aan staat. Wij gebruiken dus netjes de volledige open- en sluittags.

Echo
In het eerste voorbeeld hebben we gebruik gemaakt van een echo om tekst op het scherm te zetten. We zien dat de echo gevolgd wordt door een stukje tekst tussen twee enkele quotes (') en dat de regel afgesloten wordt met een punt-komma (;). Dit is de standaard manier waarop een regel in PHP afgesloten wordt.

Variabelen kunnen we gebruiken om tijdelijk gegevens in op te slaan. Deze gegevens kunnen bijvoorbeeld bestaan uit getallen (integers) of stukken tekst (strings), maar kunnen bijvoorbeeld ook waar/niet waar gegevens (booleans) of een reeks gegevens (array) bevatten. Eigenlijk alles wat we in PHP kunnen aanmaken, kunnen we in een variabele zetten.

Aanmaken van variabelen
Het aanmaken van een variabele, ook wel declareren genaamd, doe je door een dollarteken ($) gevolgd door een zelf gekozen naam te tikken. Met het is-gelijk-aan (=) teken kunnen we vervolgens een waarde aan de variabele toekennen. Tenslotte sluiten we de regel weer af met een punt-komma zoals dat bij elke PHP regel hoort.

<?php
$tekst = 'Hello World!';
echo $tekst;
?>

In dit stukje code declareren we de variabele $tekst en kennen er de waarde 'Hello World!' aan toe. Vervolgens gebruiken we een echo om de inhoud van $tekst op het scherm te zetten. De output is als volgt:

Hello World!

Verschillende typen variabelen
Zoals ik al eerder vermelde, kunnen we werkelijk alles binnen PHP opslaan in een variabele. Afhankelijk van de inhoud hoort een variabele tot een bepaald type. Enkele voorbeelden:

<?php
$tekst = 'Hello World!'; // String
$leeftijd = 20; // Integer
$prijs = 135.75; // Float
$check = true; // Boolean
?>

Dit zijn enkele voorbeelden van verschillende typen variabelen. De eerste variabele $tekst hebben we al eerder gezien en bevat een string. Als je getallen in een variabele opslaat, zijn het integers als het hele getallen betreffen en floats als je het over decimale getallen hebt. Een variabele die aangeeft of iets waar of niet waar is, noem je een boolean. Een type variabele die nog niet in dit voorbeeld staat, is de array. Over deze variabele komen we later in deze tutorial nog te spreken.

Zoals we zien wordt een string in PHP altijd tussen enkele quotes geplaatst. Bij een integer, float of boolean gebruiken we geen quotes.

Commentaar
Iets anders dat we in bovenstaand voorbeeld zien zijn de stukjes die vooraf gegaan worden door een dubbele slash (//). Dit is de manier waarop we commentaar bij de code kunnen zetten. Er zijn drie mogelijke manieren:

<?php
// Dit is een enkele regel commentaar

# Ook dit is een enkele regel commentaar

/* Dit is een commentaar blok
dat over meerdere regels verdeeld
kan zijn. */
?>

Het aanbrengen van commentaar in je code heeft een aantal doelen. Allereerst gebruik je het zodat anderen die je code lezen begrijpen wat bepaalde delen uit je code doen. Daarnaast is het ook voor jezelf handig als je na een paar maanden je code weer wilt aanpassen en je niet precies meer weet wat je nu gedaan had. Het commentaar kan dan een hoop verduidelijken.

Tenslotte kun je commentaar gebruiken om tijdens het debuggen van je script een bepaald deel van de code niet uit te voeren. Commentaar wordt namelijk niet geparsed door de webserver.

Naamgeving
Naamgeving van variabelen is belangrijk. Probeer altijd een naam te kiezen die iets over de inhoud van een variabele zegt. Een variabele als $tekst zegt natuurlijk weinig over de inhoud, dus je hebt geen idee wat erin staat. Een goede manier van naamgeven is bijvoorbeeld $sWelkomstTekst. Hierin geeft de eerste 's' aan dat het een string betreft en de rest van de naam geeft informatie over de inhoud.

<?php
$sTekst = 'Hello World!'; // String
$iLeeftijd = 20; // Integer
$fPrijs = 135.75; // Float
$bCheck = true; // Boolean
?>

Dit is de manier die ik in de rest van de tutorial zal hanteren.

Variabelen buiten quotes
Bovenstaand voorbeeld laat zien hoe we een enkele variabele kunnen echoën. Maar het zal vaak genoeg voorkomen dat je een variabele in een deel van een string wilt echoën of dat je meerdere variabelen achter elkaar wilt echoën.

Nu weten we dat strings altijd tussen enkele quotes moeten staan, maar als we de variabele ook tussen de quotes zetten, gaat het niet helemaal goed. Een variabele tussen enkele quotes wordt namelijk niet geparsed, de naam van de variabele wordt in dat geval weergegeven. Dat is de reden dat we variabele altijd 'buiten quotes halen'.

<?php
$sWelkomstTekst = 'Hello World!';

echo 'Dit is de welkomsttekst: $sWelkomstTekst <br />'; // FOUT
echo 'Dit is de welkomsttekst: '.$sWelkomstTekst.' <br />'; // GOED
?>

Dit is de welkomsttekst: $sWelkomstTekst
Dit is de welkomsttekst: Hello World!

Het blijkt dat de eerste echo niet helemaal goed gegaan is. In plaats van de inhoud van de variabele wordt nu de naam weergegeven. De oplossing wordt zoals gezegd ook wel het 'variabele buiten quotes halen' genoemd. Dit doen we door de echo tijdelijk af te sluiten met een enkele quote. Vervolgens kunnen we de variabele er aan vast plakken met het concatenatieteken (.) om daarna wederom een concatenatieteken te gebruiken en verder te gaan met de echo.

Ditzelfde principe kun je gebruiken om meerdere variabelen achter elkaar weer te geven:

<?php
$sVoornaam = 'Joren';
$sAchternaam = 'de Wit';
$x = 1;
$y = 2;
$z = 3;

$sNaam = $sVoornaam.' '.$sAchternaam;
echo $sNaam.'<br />';
echo $x.$y.$z;
?>

Joren de Wit
123

Eerst hebben we $sVoornaam en $sAchternaam met een spatie ertussen samengevoegd tot $sNaam. Daarna hebben we de verschillende variabelen geëchoed.

Rekenen met variabelen
We hebben al gezien dat we variabelen kunnen echoën, maar dat is niet het enige. Het rekenen met variabelen in PHP is iets dat we veelvuldig zullen gebruiken. Enkele voorbeelden:

<?php
$iAantal = 10;
$fPrijs = 9.95;

$fSubtotaal = $iAantal * $fPrijs;
echo 'Subtotaal: '.$fSubtotaal.'<br />';

$fBtw = $fSubtotaal * 0.19;
$fTotaal = $fSubtotaal + $fBtw;
echo 'Totaal: '.$fTotaal;
?>

Subtotaal: 99.5
Totaal: 118.405

Andere operators die je kunt gebruiken om berekeningen uit te voeren zijn de - voor het aftrekken van twee waarden en de / om twee waarden op elkaar te delen.

Nu we een beetje weten hoe we met variabelen in PHP kunnen werken, is het tijd om iets verder te gaan kijken. Alles dat we tot nu toe gezien hebben, zouden we in principe ook nog met simpele HTML code kunnen bereiken. Laten we nu eens wat dieper ingaan op een van de dynamische aspecten van PHP.

If/else statements
Statement is het Engels voor 'voorwaarde' en wordt zeer veel in PHP scripts gebruikt. Met PHP is het mogelijk om verschillende acties uit te voeren afhankelijk van de uitkomst van een bepaalde voorwaarde. De meest simpele voorwaarde die we kunnen stellen is de vergelijking van twee waarden. Zo zou je PHP bijvoorbeeld kunnen laten bepalen of een variabele groter of kleiner is dan 5 en afhankelijk daarvan een reactie geven.

De makkelijkste constructie waarin we zo'n statement op kunnen nemen is een if/else constructie. De syntax ziet er als volgt uit:

<?php
if( statement )
{
    // Doe iets
}
else
{
    // Doe iets anders
}
?>

De constructie begint met een if en vervolgens de voorwaarde tussen haakjes erachter. Tussen accolades {} volgt vervolgens het gedeelte dat uitgevoerd wordt als aan de vooraarde voldaan wordt. De else, die overigens niet verplicht is, bevat een alternatieve actie die uitgevoerd wordt als niet aan de voorwaarde voldaan wordt.

<?php
$x = 4;
if($x > 5)
{
	echo $x.' is groter dan 5';
}
else
{
	echo $x.' is niet groter dan 5';
}
?>

4 is niet groter dan 5

Allereerst kennen we de waarde 4 aan de variabele $x toe. Vervolgens controleren we in het if-statement of de variabele $x groter is dan 5 en voeren afhankelijk van die uitkomst een actie uit. In dit geval is dat een echo die de bepaalde situatie omschrijft.

Op deze pagina kun je een volledig overzicht vinden van de beschikbare vergelijkings operators. Ook kun je daar de werking van de verschillende operators onderzoeken.

De if/else constructie uit het vorige voorbeeld kunnen we nog iets verder uitbreiden:

<?php
$x = 5;

if($x > 5)
{
	echo $x.' is groter dan 5';
}
elseif($x == 5)
{
	echo $x.' is precies 5';
}
else
{
	echo $x.' is niet groter dan 5';
}
?>

5 is precies 5

Op deze manier kunnen we een if/elseif/else constructie in theorie oneindig ver uitbreiden. Er zit namelijk geen beperking op het aantal elseif statements.

Ook is het mogelijk om meerdere vergelijkingen in 1 statement op te nemen. Zo zouden we bijvoorbeeld kunnen controleren of $x groter is dan 5 en $y kleiner is dan 10:

<?php
$x = 6;
$y = 8;

if($x > 5 && $y < 10)
{
	echo '$x is groter dan 5 en $y is kleiner dan 10';
}
?>

$x is groter dan 5 en $y is kleiner dan 10

Met behulp van de && (AND) operator kunnen we dus controleren of aan beide vergelijkingen voldaan wordt. De tegenhanger hiervan is de || (OR) operator waarmee je controleert of aan minimaal 1 van de vergelijkingen voldaan wordt.

In voorgaande voorbeelden hebben we enkel gekeken of een bepaalde vergelijking waar is. We kunnen ook het omgekeerde doen en kijken of een bepaalde vergelijking niet waar is:

<?php
$x = 4;
if(!($x > 5))
{
	echo $x.' is niet groter dan 5';
}
else
{
	echo $x.' is groter dan 5';
}
?>

4 is niet groter dan 5

Nu zien we dat het if-statement een waarheid oplevert en dus uitgevoerd wordt. Het ! in het if-statement levert dus: 'Als de volgende vergelijking niet waar is ...'.

Overigens zul je dit voorbeeldje niet vaak gebruiken om te controleren of iets niet groter is dan 5. Je zult dan meestal namelijk controleren of iets kleiner dan of gelijk aan 5 is:

<?php
if($x <= 5)
{
    echo $x.' is niet groter dan 5';
}
?>

Een overzicht met alle soorten operators is te vinden op php.net.

Switch statement
Als je een hele lange lijst met elseif statements krijgt, zou je die kunnen vervangen door een alternatieve constructie. Met een zogenaamd switch statement kun je een hele reeks voorwaarden loslaten op een bepaalde variabele. Dat ziet er bijvoorbeeld zo uit:

<?php
$x = 1;

switch($x)
{
	case 0 :
		echo '$x is gelijk aan 0';
		break;
	case 1 :
		echo '$x is gelijk aan 1';
		break;
	case 2 : 
		echo '$x is gelijk aan 2';
		break;
	default :
		echo '$x voldoet niet aan een van de genoemde voorwaarden';
}		
?>

$x is gelijk aan 1

Met een switch statement kun je dus controleren welke waarde een variabele heeft. Je kunt net zoveel cases aanmaken als je wilt. Hierin controleer je of de variabele aan een bepaalde waarde voldoet. Achter de dubbele punt zet je vervolgens de code die je uit wilt voeren als de variabele aan de waarde in de case voldoet. Tenslotte sluit je de case af met een break. Gebruikelijk is het om ook een default actie mee te geven aan het switch statement, welke uitgevoerd wordt als de variabele aan geen van de cases voldoet.

Ingewikkeldere statements zijn echter ook mogelijk in een switch:

<?php
$x = 10;

switch($x)
{
	case $x > 10 :
		echo '$x is groter dan 10';
		break;
	case $x == 10 :
		echo '$x is gelijk aan 10';
		break;
	case $x < 10 : 
		echo '$x is kleiner dan 10';
		break;
	default :
		echo '$x voldoet niet aan een van de genoemde voorwaarden';
}		
?>

$x is gelijk aan 10

Op deze manier kunnen we een switch statement zo ingewikkeld maken als we maar willen. De keuze voor het gebruik van een switch statement hangt in de meeste gevallen af van de lengte van de if/else constructie en de hoeveelheid code die per statement uitgevoerd wordt.

Bij veel statements en weinig code per statement, is een switch makkelijk. Maar naarmate de hoeveelheid code toeneemt, is het waarschijnlijk weer overzichtelijker om toch met een if/else constructie te werken. Tenslotte ben je met een if/else constructie nog een stuk flexibeler.

Een andere constructie waarbij het dynamische aspect van PHP naar voren komt, is de loop. Dit is een constructie waarbij een bepaald stuk code herhaaldelijk uitgevoerd wordt tot aan een bepaald statement wordt voldoen. Er zijn verschillende soorten loops die we kunnen gebruiken. Ik zal de twee die het meest gebruikt worden, de while-loop en de for-loop hier bespreken.

While
De syntax van de while-loop ziet er als volgt uit:

<?php
while( statement )
{
    // Doe iets
}
?>

Zolang aan statement voldaan wordt, zal de code in de loop, die wederom tussen accolades {} staat, telkens opnieuw uitgevoerd worden. Vaak wordt een while-loop in combinatie met een tellertje gebruikt, bijvoorbeeld om de getallen 1-10 weer te geven:

<?php
$i = 1;
while($i <= 10)
{
	echo $i.' ';
	$i++;
}
?>

1 2 3 4 5 6 7 8 9 10

De vertaling van dit stukje code is als volgt: 'Zolang $i kleiner dan of gelijk aan 10 is, echo $i en verhoog de waarde van $i met 1'. De uitdrukking $i++ zorgt er dus voor dat de waarde van $i met 1 opgehoogd wordt. Merk op de variabele $i al aangemaakt moet zijn voordat de while-loop begint, anders zal PHP het niet slikken. Later in deze tutorial zullen we uitgebreidere constructies met while-loops zien.

For
Een tweede soort loop is de for-loop. Hoewel deze eigenlijk precies hetzelfde doet, is de syntax iets anders:

<?php
for( beginconditie ; statement ; increment )
{
    // Doe iets
}
?>

In de beginconditie stel je de beginwaarden voor de loop in. Dit zou bijvoorbeeld het declareren van de variabele $i kunnen zijn, zoals we dat ook voor de while loop deden. Het statement is hetzelfde als bij de while-loop en het increment gedeelte bepaalt wat er na elke loop met de variabelen uit de beginconditie gebeurt.

Ook nu is het weer mogelijk om de getallen 1-10 te genereren:

<?php
for($i = 1; $i <= 10; $i++)
{
	echo $i.' ';
}
?>

1 2 3 4 5 6 7 8 9 10

Deze constructie zou dezelfde vertaling hebben als het voorbeeld hiervoor, alleen zitten de verschillende onderdelen op een andere plaats. Zo vormt $i = 1 de beginconditie, is het statement hetzelfde als in de while-loop en vormt $i++ het increment gedeelte.

Een type variabele dat we nog niet behandeld hebben zijn de arrays. Een array is een datastructuur waarin een reeks gegevens opgeslagen is. Je kunt het zien als een variabele die meerdere waarden bevat.

Een array bestaat uit één of meerdere rijen (entries) die allemaal een eigen sleutel, een indentificatie middel, en een waarde hebben. Als je bij het declareren van een array geen sleutel meegeeft aan de waarden, genereert PHP er zelf een. De eerste sleutel is dan 0, de tweede 1, enzovoort.

Het aanmaken van een array
Het declareren van een array gaat bijna hetzelfde als het declareren van een variabele. Alleen geven we nu de variabele niet een normale waarde zoals een string of integer, maar kennen we een array als waarde toe.

<?php
$aFruit = array('appel', 'peer', 'banaan', 'kiwi');	
?>

De array $aFruit (denk weer even aan de naamgeving van variabelen) bevat nu verschillende items. Om te zien hoe deze array eruit ziet, kunnen we de volgende code gebruiken:

<?php
$aFruit = array('appel', 'peer', 'banaan', 'kiwi');
echo '<pre>'.print_r($aFruit, true).'</pre>';
?>

Array
(
    [0] => appel
    [1] => peer
    [2] => banaan
    [3] => kiwi
)

Die print_r() is een functie om de inhoud van een array weer te geven. Later in deze tutorial zullen we dat nog terugzien, voor nu gebruiken we het gewoon.

We zien nu hoe de array $aFruit opgebouwd is. Tussen de blokhaken [] staat de sleutel en achter de => de waarde. Omdat wij bij het declareren geen sleutels opgegeven hebben, heeft PHP die zelf aangemaakt. Merk op dat de eerste sleutel van de array 0 is en niet 1 zoals je misschien zou verwachten.

Associatieve array
Een associatieve array is een array waarbij de sleutels strings zijn. Dit in tegenstelling tot de numerieke array waarbij de sleutels integers zijn. Als we een associatieve array aan willen maken, kunnen we dat op de volgende manier doen:

<?php
$aFruitAantallen = array (
	'appel' => 10,
	'peer' => 0,
	'banaan' => 4,
	'kiwi' => 12 );

echo '<pre>'.print_r($aFruitAantallen, true).'</pre>';
?>

Array
(
    [appel] => 10
    [peer] => 0
    [banaan] => 4
    [kiwi] => 12
)

De array $aFruitAantallen heeft een iets andere indeling. De sleutels zijn nu de fruitsoorten en de bijbehorende waarden geven de aantal van iedere soort. Hoe we deze array op een nette manier kunnen uitlezen, zal ik zodadelijk laten zien.

Uitlezen van waarden uit een array
Om een enkele waarde uit een array uit te lezen, nemen we de variabelenaam van de array en plaatsen we de gewenste sleutel in blokhaken erachter:

<?php
$aFruit = array('appel', 'peer', 'banaan', 'kiwi');
echo 'Een '.$aFruit[0].' is lekker, een '.$aFruit[3].' wat minder.';
?>

Een appel is lekker, een kiwi wat minder.

De associatieve array kunnen we op precies dezelfde manier uitlezen:

<?php
$aFruitAantallen = array (
	'appel' => 10,
	'peer' => 0,
	'banaan' => 4,
	'kiwi' => 12 );

echo 'Ik heb '.$aFruitAantallen['appel'].' appels en '.$aFruitAantallen['banaan'].' bananen.';
?>

Ik heb 10 appels en 4 bananen.

In dit geval moeten we de sleutel wel tussen enkele quotes plaatsen aangezien we met een string te maken hebben. En zoals we weten moeten we strings altijd tussen enkele quotes plaatsen.

Foreach loop
Een andere manier van het uitlezen van een complete array, is het gebruik van een foreach loop. Met deze loop lopen we door alle entries in een array en kunnen we ze weergeven. De syntax van een foreach loop is als volgt:

<?php
foreach($aArray as $sKey => $sValue)
{
    // Doe iets met $sKey en/of $sValue
}
?>

In deze syntax is $aArray vanzelfsprekend de uit te lezen array. De variabele $sKey is de sleutel van de huidige entry en $sValue de bijbehorende waarde. Het opvragen van $sKey is overigens optioneel, als je dit gedeelte weglaat wordt alleen de waarde in $sValue geladen.

Laten we de inhoud van de array $aFruit eens op het scherm zetten:

<?php
$aFruit = array('appel', 'peer', 'banaan', 'kiwi');

echo '<b>Fruitsoorten:</b><br />';
foreach($aFruit as $sFruit)
{
	echo $sFruit.'<br />';
}
?>

Fruitsoorten:
appel
peer
banaan
kiwi

Je ziet dat ik hier de variabele $sKey in de foreach loop niet gebruikt hebben. De sleutels van deze array zijn niet interessant, dus hoef ik ze ook niet weer te geven. Dat is echter anders bij onze associatieve array:

<?php
$aFruitAantallen = array (
	'appel' => 10,
	'peer' => 0,
	'banaan' => 4,
	'kiwi' => 12 );

echo '<b>Fruit en aantallen:</b><br />';
foreach($aFruitAantallen as $sFruit => $iAantal)
{
	echo $sFruit.': '.$iAantal.'<br />';
}
?>

Fruit en aantallen:
appel: 10
peer: 0
banaan: 4
kiwi: 12

Met deze foreach loop hebben we de sleutel van elke entry geladen in de variabele $sFruit en het aantal in $iAantal (what's in the name). Vervolgens kunnen we deze gegevens met een eenvoudige echo op het scherm zetten.

Het toevoegen van waarden aan een array
Nu we gezien hebben hoe we een array aan kunnen maken en de waarden kunnen uitlezen, kunnen we nu kijken naar het toevoegen van waarden aan een array. Hiervoor zijn een aantal verschillende manieren.

De eerste manier is door het gebruik van blokhaken zonder inhoud achter de variabelenaam:

<?php
$aFruit = array();
$aFruit[] = 'appel';
$aFruit[] = 'peer';

echo '<pre>'.print_r($aFruit, true).'</pre>';
?>

Array
(
    [0] => appel
    [1] => peer
)

We beginnen met het aanmaken van een lege array $aFruit. Vervolgens voegen we daar op bovenstaande manier twee nieuwe waarden aan toe. Omdat we geen sleutel meegeven zal PHP zelf sleutels toekennen.

Een andere manier is door het gebruik van de functie array_push(). Over functies komen we later nog te spreken, dus neem dit voorbeeld gewoon voor lief:

<?php
$aFruit = array();
$aFruit[] = 'appel';
$aFruit[] = 'peer';
array_push($aFruit, 'banaan', 'kiwi');

echo '<pre>'.print_r($aFruit, true).'</pre>';
?>

Array
(
    [0] => appel
    [1] => peer
    [2] => banaan
    [3] => kiwi
)

Met deze functie is het dus mogelijk om meerdere variabelen in een keer aan de array toe te voegen. De keuze tussen deze twee methoden is dan ook puur afhankelijk van de situatie. De eerste methode krijgt echter de voorkeur bij associatieve arrays zoals we nu zullen zien.

Associatieve arrays
In het geval van een associatieve array, zullen wederom zelf onze sleutels moeten definiëren. Waarden toevoegen aan een associatieve array lukt dan ook alleen op de manier met blokhaken:

<?php
$aFruitAantallen = array();
$aFruitAantallen['appel'] = 10;
$aFruitAantallen['peer'] = 0;
$aFruitAantallen['banaan'] = 4;
$aFruitAantallen['kiwi'] = 12;

echo '<pre>'.print_r($aFruitAantallen, true).'</pre>';
?>

Array
(
    [appel] => 10
    [peer] => 0
    [banaan] => 4
    [kiwi] => 12
)

Let ook hier wederom op de quotes die we rond de strings moeten plaatsen.

Multidimensionale arrays
Multidemensionale arrays zijn, zoals het woord al doet vermoeden, arrays met meerdere dimensies. Dat wil zeggen, het zijn arrays in arrays. Dit soort toepassingen van arrays kom je in vrij veel scripts tegen en is bovendien heel handig in het gebruik.

Aanmaken
Het declareren van een multidimensionale array gaat als volgt:

<?php
$aVakantieBestemmingen = array (
	'Wintersport' => array (
		'Westendorf',
		'Gerlos',
		'Kitzbühl',
		'Mayerhofen' 
	),
	'Zonvakantie' => array (
		'Curacao',
		'Spanje',
		'Italië',
		'Brazilië' 
	)
);

echo '<pre>'.print_r($aVakantieBestemmingen, true).'</pre>';
?>

Array
(
    [Wintersport] => Array
        (
            [0] => Westendorf
            [1] => Gerlos
            [2] => Kitzbühl
            [3] => Mayerhofen
        )
    [Zonvakantie] => Array
        (
            [0] => Curacao
            [1] => Spanje
            [2] => Italië
            [3] => Brazilië
        )
)

Zoals je ziet gebruiken we hier een multidimensionale array om een onderscheid te maken van het soort vakanties. Natuurlijk hadden we ook twee aparte arrays voor de wintersport en zonvakanties kunnen gebruiken, maar het is niet nodig.

Uitlezen
Het uitlezen van de multidmensionale array gaat op precies dezelfde manier als elke andere array. Alleen zullen we nu twee sets blokhaken moeten gebruiken om de juiste entry te selecteren:

<?php
$aVakantieBestemmingen = array (
	'Wintersport' => array (
		'Westendorf',
		'Gerlos',
		'Kitzbühl',
		'Mayerhofen' 
	),
	'Zonvakantie' => array (
		'Curacao',
		'Spanje',
		'Italië',
		'Brazilië' 
	)
);

echo 'De wintersport in '.$aVakantieBestemmingen['Wintersport'][3].' was geweldig, maar ik ga volgend jaar toch liever naar '.$aVakantieBestemmingen['Zonvakantie'][1].'.';
?>

De wintersport in Mayerhofen was geweldig, maar ik ga volgend jaar toch liever naar Spanje.

Mochten we de array met een foreach loop uit willen lezen, dan zullen we er ook daar twee van moeten gebruiken:

<?php
$aVakantieBestemmingen = array (
	'Wintersport' => array (
		'Westendorf',
		'Gerlos',
		'Kitzbühl',
		'Mayerhofen' 
	),
	'Zonvakantie' => array (
		'Curacao',
		'Spanje',
		'Italië',
		'Brazilië' 
	)
);

foreach($aVakantieBestemmingen as $sSoort => $aLocaties)
{
	echo '<b>'.$sSoort.'</b><br />';
	foreach($aLocaties as $sLocatie)
	{
		echo $sLocatie.'<br />';
	}
}
?>

Wintersport
Westendorf
Gerlos
Kitzbühl
Mayerhofen
Zonvakantie
Curacao
Spanje
Italië
Brazilië

Het zal in het begin misschien even wennen zijn hoe je deze foreach loops toe moet passen maar als je er eenmaal achter bent, zul je de vele mogelijkheden ervan ontdekken.

Toevoegen
Tenslotte is er nog het toevoegen van nieuwe waarden aan een multidimensionale array. Ook dat kan op verschillende manieren:

<?php
// Lege array aanmaken
$aVakantieBestemmingen = array ();

// Array toevoegen
$aVakantieBestemmingen['Wintersport'] = array (
	'Westendorf',
	'Gerlos',
	'Kitzbühl',
	'Mayerhofen' 
);

// Losse entries invoegen
$aVakantieBestemmingen['Zonvakantie'][] = 'Curacao';
$aVakantieBestemmingen['Zonvakantie'][] = 'Spanje';

// Losse entries invoegen met array_push
array_push($aVakantieBestemmingen['Zonvakantie'], 'Italië', 'Brazilië');

echo '<pre>'.print_r($aVakantieBestemmingen , true).'</pre>';
?>

Array
(
    [Wintersport] => Array
        (
            [0] => Westendorf
            [1] => Gerlos
            [2] => Kitzbühl
            [3] => Mayerhofen
        )
    [Zonvakantie] => Array
        (
            [0] => Curacao
            [1] => Spanje
            [2] => Italië
            [3] => Brazilië
        )
)

Op de vorige pagina hebben we al gewerkt met een van de vele php functies, array_push(). Deze functies kunnen we gebruiken om variabelen te manipuleren, gegevens te controleren, arrays te bewerken en nog veel meer. Het doel van een functie is een bepaalde bewerking die je vaker in een PHP script gebruikt te vereenvoudigen. Naarmate we verder komen in deze tutorial, zullen we steeds meer php functies gaan gebruiken. In dit hoofdstuk gaan we het echter hebben over het zelf schrijven van functies.

Zelf functies schrijven
Naast de vele functies die PHP rijk is, is het ook mogelijk om zelf functies te schrijven en te gebruiken. Een functie is dus een stukje script dat we aan kunnen roepen, eventueel parameters aan mee kunnen geven en vervolgens een bewerking uitvoert. Uiteindelijk zou het kunnen zijn dat een functie nog een waarde teruggeeft, maar dat hoeft niet. De syntax van elke functie ziet er als volgt uit:

<?php
function functieNaam ( parameters )
{
    // Body
}
?>

Met function geven we aan dat we een eigen functie definiëren. Dan volgt de naam van de functie en tussen haakjes de eventuele parameters die we aan deze functie mee kunnen geven. Tussen de accolades volgen dan de bewerkingen die deze functie aan de hand van de eventuele parameters uit gaat voeren.

Functies zonder parameters
Zoals gezegd kan een functie op waarden teruggeven. Allereerst kan dat door simpel gegevens binnen de functie te echoën, maar een functie kan ook waarden returnen. Hoe dat in zijn werk gaat zullen we zo zien. We kijken eerst naar een functie die wat tekst op het scherm zet:

<?php
// Functie definiëren
function geefWeer()
{
	echo 'Hello World!';
}

// Functie aanroepen
geefWeer();
?>

Hello World!

We hebben nu de functie geefWeer() gedefinieerd. Door de functie nu aan te roepen op de manier in bovenstaand voorbeeld, wordt de functie uitgevoerd. Dat resulteert in een echo van 'Hello World!'.

Zoals gezegd kan een functie ook waarden teruggeven:

<?php
// Functie definiëren
function geefTerug()
{
	return 'Hello World!';
}

// Functie aanroepen
echo geefTerug();
?>

Hello World!

In de functie geefTerug() zien we dat de echo vervangen is door een return. Dit zorgt ervoor dat de string 'Hello World!' terug gegeven wordt door de functie. Het lijkt nu net alsof we de functie zelf echoën, maar in werkelijkheid echoën we het resultaat van de functie. Uiteraard zou je de terug gegeven waarde ook in een variabele kunnen opslaan:

<?php
$sTekst = geefTerug();
?>

Als je nu vervolgens $sTekst zou echoën, zou je hetzelfde resultaat krijgen.

Functies met parameters
PHP functies kunnen ook parameters accepteren. Deze zijn dan beschikbaar voor gebruik in de functie zelf:

<?php
// Functie definiëren
function geefWeer($sString)
{
	echo $sString.'<br />';
}

// Functie aanroepen
$sTekst = 'Hello World!';
geefWeer($sTekst);
geefWeer('Een tweede tekst');
?>

Hello World!
Een tweede tekst

Onze geefWeer() functie accepteert nu een parameter $sString. Als we bij het aanroepen van een functie nu ook een parameter opgeven, zal die parameter gebruikt worden in de bewerking. In het geval van bovenstaande functie zal de opgegeven tekst op het scherm weergegeven worden.

Meer functies...
Stel dat we bijvoorbeeld regelmatig willen weten hoeveel items een array bevat. Dan zouden we daar zelf een functie voor kunnen schrijven.

<?php
// Functie definiëren
function tel($aArray)
{
	// Aantal start op 0
	$iAantal = 0;
	
	// Array doorlopen en telkens 1 bij $iAantal optellen
	foreach($aArray as $sValue)
	{
		// Tel 1 bij $iAantal op
		$iAantal++;
	}
	
	// Gevonden aantal teruggeven
	return $iAantal;
}

// Functie aanroepen
$aTestArray = array(1, 2, 3, 4);
echo '$aTestArray bevat '.tel($aTestArray).' items.';
?>

$aTestArray bevat 4 items.

Aan onze tel() functie geven we een array als parameter mee. Vervolgens doorlopen we alle items van de array waarbij we een teller $iAantal bijhouden. Tenslotte retourneren we $iAantal en echoën we het gevonden aantal.

De oplettende lezer, die al wat meer PHP kennis heeft, zal direct zeggen: 'He, maar daar is toch al een PHP functie voor?'. Dat klopt! De functie count() doet precies hetzelfde, maar het gaat hier om het voorbeeld.

Een controle functie...
Functies zijn bij uitstek geschikt om te gebruiken voor de controle van variabelen. Stel dat we van een gebruikersnaam willen weten of deze wel langer dan 3 tekens is en niet begint met een A dan zouden we het volgende kunnen doen:

<?php
if(strlen($sGebruikersnaam) > 3 && substr($sGebruikersnaam, 0, 1) != 'A')
{
    echo 'Gebruikersnaam is goed';
}
else
{
    echo 'Gebruikersnaam ongeldig!';
}
?>

De functie strlen() gebruiken we om de lengte van een string te bepalen en met substr() kunnen we een bepaald gedeelte van een string selecteren.

Maar als we deze controle vaker in ons script willen uitvoeren, is het wellicht makkelijker om daar een functie voor te schrijven:

<?php
// Functie definiëren
function checkGebruikersnaam($sGebruikersnaam)
{
	if(strlen($sGebruikersnaam) > 3 && substr($sGebruikersnaam, 0, 1) != 'A')
	{
		return true;
	}
	else
	{
		return false;
	}
}

// Functie aanroepen
$sGebruiker = 'Joren';
if(checkGebruikersnaam($sGebruiker))
{
	echo 'Deze gebruikersnaam is geldig!';
}
else
{
	echo 'Ongeldige gebruikersnaam';
}
?>

Deze gebruikersnaam is geldig!

Nu hebben we de controle overgebracht naar onze functie checkGebruikersnaam(). Deze functie geeft een boolean terug afhankelijk van het slagen van de controle. Als de controle slaagt zal TRUE geretourneerd worden, anders FALSE.

Dat de functie een boolean teruggeeft is mooi. We kunnen hem dan namelijk in een if-statement opnemen zoals in bovenstaand voorbeeld. Als de controle slaagt, wordt ook aan de voorwaarde in het if-statement voldaan en wordt de betreffende echo uitgevoerd.

Optionele parameters: BTW?
We kunnen ook functies definiëren met optionele parameters. Dus parameters die niet per se ingevuld hoeven te worden. Stel dat we een functie willen schrijven die het totaalbedrag berekent aan de hand van een array met prijzen en die optie heeft om daar BTW bij op te tellen.

<?php
// Functie definiëren
function calcTotaal($aBedragen, $bBtw = false)
{
	// Totaal van prijzen berekenen
	$fTotaal = array_sum($aBedragen);
	
	// Controleren of BTW berekend moet worden
	if($bBtw)
	{
		// Het totaal * 1.19 (19% BTW)
		$fTotaal *= 1.19;
	}
	
	// Geef het berekende totaal terug
	return number_format($fTotaal, 2);
}

// Functie aanroepen
$aBedragen = array(5.45, 9.95, 34.95);
echo 'Totaal excl. BTW: '.calcTotaal($aBedragen).'<br />';
echo 'Totaal incl. BTW: '.calcTotaal($aBedragen, true).'<br />';
?>

Totaal excl. BTW: 50.35
Totaal incl. BTW: 59.92

Zoals we in bovenstaande functie kunnen zien, definiëren we een optionele parameter door de parameter een standaardwaarde toe te kennen. Als deze parameter niet opgegeven is, krijgt hij de standaardwaarde toegewezen. Is hij wel opgegeven, dan behoudt hij zijn eigen waarde.

Verder zien we in de calcTotaal() functie het gebruik van de PHP functie array_sum(). Deze functie telt alle waarden in de array bij elkaar op en geeft het totaal terug.

Daarnaast zien we nog het gebruik van de operator *=. Deze operator doet precies hetzelfde als:

<?php
$fTotaal = $fTotaal * 1.19;
?>

Het is alleen een stuk korter. Want ja, programmeurs zijn lui dus waarom zouden we meer schrijven dan nodig is.

Tenslotte gebruiken we nog de functie number_format() om de weergave van de bedragen een beetje op te maken. Aan een bedrag met 4 cijfers achter de komma hebben we natuurlijk niet zo veel.

Een van de eerste toepassingen van PHP die een beginnende programmeur gebruikt, is vaak de afhandeling van een formulier. Het is dan ook een toepassing waar PHP uitermate geschikt voor is! Ik zal beginnen met eerst een korte uitleg van de HTML code van een simpel formulier, om daarna snel verder te gaan met het PHP script dat de verwerking verzorgt.

De HTML code
Laten we eens kijken naar een simpel formulier waar een gebruiker om te beginnen zijn voor en achternaam kan invullen. Zonder opmaak (dat is nu niet belangrijk) ziet de HTML code van de pagina formulier.php er als volgt uit:
[code=formulier.php]
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">;
<html xmlns="http://www.w3.org/1999/xhtml">;
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Mijn eerste formulier!</title>
</head>

<body>
<form action="verwerk.php" method="post">
<p>
<label for="voornaam">Voornaam:</label>
<input type="text" name="voornaam" id="voornaam" />
</p>
<p>
<label for="achternaam">Achternaam:</label>
<input type="text" name="achternaam" id="achternaam" />
</p>
<p>
<input type="submit" value="Verzenden" />
</p>
</form>
</body>
</html>
[/code]
Als je nog nooit een regel HTML gezien hebt, is een klein beetje uitleg waarschijnlijk wel gewenst. Ik zal me beperken tot het gedeelte tussen de <body> tags, aangezien dat het gedeelte is dat op het scherm weergegeven wordt.

De <form> tag geeft zoals verwacht aan dat we een formulier tonen. Het action attribuut bevat de naam van de pagina waar het formulier zijn gegevens heen stuurt. Dit is dus de naam van de pagina die wij straks gaan maken. Het method attribuut heeft twee mogelijke waarden: get en post. In het geval van GET worden de ingevulde waarden meegezonden in de URL. Bij de POST methode worden de variabelen onzichtbaar naar de andere pagina verzonden.

Vervolgens zien we twee <input> velden. Het type attribuut geeft het soort inputveld aan. We gebruiken nu twee text velden, maar later zullen we ook andere varianten zien. De name is de naam van het input veld en gebruiken we tijdens de verwerking om de inhoud van dat veld op te halen. Het id gebruik je voornamelijk met Javascript, maar het is een goede gewoonte om deze dezelfde waarde als de name te geven.

Klik hier voor een werkend voorbeeld van het formulier.

Verwerking van het formulier: de code
Genoeg geluld over de HTML, laten we eens kijken hoe we het formulier controlen met PHP. Er zijn een aantal onderdelen die altijd aanwezig moeten zijn in de verwerking van een formulier. Op volgorde van verschijning in het script:

[li]Controleren of er een formulier gepost is[/li]
[li]Controleren of de vereiste velden ingevuld zijn[/li]
[li]Eventuele andere controles op de velden uitvoeren[/li]
[li]Geen errors? Gegevens verwerken.[/li]
[li]Wel errors? Fouten weergeven en terug naar formulier[/li]

Ik zal beginnen met de complete code van de verwerking en deze vervolgens stap voor stap bespreken. Schrik niet als het er moeilijk uitziet of als je dingen tegenkomt die je niet kent, we gaan er zo uitgebreid naar kijken.
[code=verwerk.php]
<?php
include '../../inc/stats.php';
// Controle of een formulier gepost is
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
// Arrays declareren voor opslag van fouten en data
$aErrors = array();
$aData = array();

// Velden die in het formulier aanwezig moeten zijn
$aFormulierVelden = array('voornaam', 'achternaam');

// Alle formuliervelden doorlopen
foreach($aFormulierVelden as $sVeld)
{
// Controleren of er een waarde voor het formulierveld bestaat
if(isset($_POST[$sVeld]))
{
// Spaties aan begin en eind weghalen
$sValue = trim($_POST[$sVeld]);

// Controle of variabele gevuld is
if(empty($sValue))
{
// Foutmelding toevoegen
$aErrors[] = 'Je bent vergeten om '.$sVeld.' in te vullen';
}

// Ingevulde waarden aan data array toevoegen
$aData[$sVeld] = $sValue;
}
else
{
$aErrors[] = 'Het veld '.$sVeld.' is niet gepost!';
}
}

// Controleren of er geen fouten opgetreden zijn
if(empty($aErrors))
{
// Formulier succes!
echo '<p>Je hebt het formulier succesvol ingevuld! De volgende gegevens zijn bekend:</p>';
echo '<p>Voornaam: '.$aData['voornaam'].'<br />';
echo 'Achternaam: '.$aData['achternaam'].'</p>';
}
else
{
// Fouten opgetreden: weergeven en terug naar formulier
header('Refresh: 3; url=formulier.php');
foreach($aErrors as $sError)
{
echo '<p style="color:red">'.$sError.'</p>';
}
}
}
else
{
// Verwerk.php mag nog niet bezocht worden, terug naar het formulier
header('Location: formulier.php');
}
?>
[/code]
Wat een lap onbegrijpbare code denk je wellicht, maar daar gaan we nu verandering in brengen!

Verwerking van het formulier: de uitleg
Aan de hand van de verschillende onderdelen die in een verwerkingsscript aanwezig moeten zijn, zal ik dit formulier met je doorlopen.

1. Controleren of een formulier gepost is

<?php
// Controle of een formulier gepost is
if($_SERVER['REQUEST_METHOD'] == 'POST')
?>

Bij het stukje over de HTML code vertelde ik over het method attribuut. Dat zien we hier nu terug. Aangezien in het formulier 'post' gebruikten, kunnen we hier op deze manier controleren of een formulier gepost is. De superglobal $_SERVER['REQUEST_METHOD'] heeft namelijk de waarde 'POST' als dat het geval is. Over superglobals komen we overigens later nog te spreken, voor nu laten we dat nog even voor wat het is.

2. Controleren of de vereiste velden ingevuld zijn
In dit geval beschouwen we zowel de voornaam als achternaam als een vereist veld. We willen dus van allebei weten of er een waarde ingevuld is. De ingevulden waarden zijn te vinden in de array $_POST (weer zo'n superglobal).

Allereerst zetten we de namen van alle velden die in ons formulier voorkomen in een array. Dit geeft ons de mogelijkheid om daadwerkelijk te controleren of alle velden wel ingevuld zijn:

<?php
// Velden die in het formulier aanwezig moeten zijn
$aFormulierVelden = array('voornaam', 'achternaam');
?>

Vervolgens kunnen we deze array met een foreach loop doorlopen. Voor elk veld controleren we vervolgens of er een waarde in de $_POST array bestaat, dan weten we zeker dat de eventuele waarde van het veld in ieder geval gepost is.

<?php
// Alle formuliervelden doorlopen
foreach($aFormulierVelden as $sVeld)
{
	// Controleren of er een waarde voor het formulierveld bestaat
	if(isset($_POST[$sVeld]))
	{	
		// Spaties aan begin en eind weghalen
		$sValue = trim($_POST[$sVeld]);
		
		// Controle of variabele gevuld is
		if(empty($sValue))
		{
			// Foutmelding toevoegen
			$aErrors[] = 'Je bent vergeten om '.$sVeld.' in te vullen';
		}
		
		// Ingevulde waarden aan data array toevoegen
		$aData[$sVeld] = $sValue;
	}
	else
	{
		$aErrors[] = 'Het veld '.$sVeld.' is niet gepost!';
	}
}
?>

Als het veld niet bestaat voegen we een foutmelding toe aan de array $aErrors. Bestaat het veld wel, dan gaan we verder met de controle. Met de functie trim() verwijderen we loze spaties aan het begin en eind van de de input om vervolgens met empty() te controleren of de waarde wel ingevuld is. Zo niet, dan voegen we weer een foutmelding toe aan de array $aErrors.

Tenslotte voegen we de ingevulde waarde toe aan de array $aData.

<?php
// Ingevulde waarden aan data array toevoegen
$aData[$sVeld] = $sValue;
?>

Als sleutel geven we de naam van het veld op. Zo weten we tenminste uit welk veld die waarde kwam. Dit stukje code wordt dus toegepast op elk veld dat wij gedefinieerd hebben in de array $aFormulierVelden.

3. Eventuele andere controles op de velden uitvoeren
Wij hebben op dit moment geen andere controles, dus dit slaan we over. Hadden we wel overige controles, dan hadden we die in de foreach loop toegepast. Wees gerust, dit komt in een later voorbeeld nog wel...

4. Geen errors? Gegevens verwerken

<?php
if(empty($aErrors))
{
	// Formulier succes!
	echo '<p>Je hebt het formulier succesvol ingevuld! De volgende gegevens zijn bekend:</p>';
	echo '<p>Voornaam: '.$aData['voornaam'].'<br />';
	echo 'Achternaam: '.$aData['achternaam'].'</p>';
}
?>

Wederom gebruiken we empty(), maar nu om te controleren of de array met foutmeldingen nog steeds leeg is. Als dat namelijk het geval is, is de controle geslaagd.

Als die array leeg is kunnen we dus verder met de verwerking van het formulier. Voor nu bestaat dat enkel uit het weergeven van de ingevulde gegevens. Herinner je dat we in stap 2 de gegevens in de array $aData hebben gezet. Daar kunnen we de gegevens nu dus ook vandaan halen. De manier van het echoën van strings en variabelen zal je nu wel bekend zijn.

Natuurlijk zijn er veel meer toepassingen voor de verwerking van deze gegevens. Zo zou je ze bijvoorbeeld weg kunnen schrijven naar een database of kunnen versturen per e-mail. Dit soort toepassingen liggen echter buiten het onderwerp van deze tutorial, dus die zal ik nu niet bespreken.

5. Wel errors? Fouten weergeven en terug naar formulier

<?php
// Fouten opgetreden: weergeven en terug naar formulier
header('Refresh: 3; url=formulier.php');
foreach($aErrors as $sError)
{
	echo '<p style="color:red">'.$sError.'</p>';
}
?>

De foutmeldingen staan in de array $aErrors. Deze kunnen we dus uitlezen met een foreach loop en de foutmeldingen op het scherm weergeven. Omdat het foutmeldingen zijn, heb ik ze even een rood kleurtje gegeven.

Dan zien we hier ook een functie die we nog niet eerder gezien hadden: header(). Deze functie gebruik je om een HTTP header naar de browser te versturen. Nu hoef je niet precies te begrijpen wat dat is, als je alleen maar onthoudt dat je er onder andere een gebruiker mee naar een andere pagina kunt sturen. Hier gebruik ik een header('Refresh: ...'), welke ervoor zorgt dat de pagina na een bepaalde tijd herladen wordt op de gegeven url. Helemaal aan het eind van verwerk.php zien we ook een header('Location: ...'), deze stuurt de gebruiker direct door naar de opgegeven pagina. Na deze vorm van header() gebruiken we altijd een exit(), zodat de rest van het script niet meer uitgevoerd wordt.

De reden dat de header() voor de foreach loop staat, is dat er voordat je deze functie aanroept, geen enkele output naar de browser plaatsgevonden mag hebben. Dus geen HTML, geen echo en zelfs geen loze spatie ergens buiten je PHP tags.

De manier waarop we nu een formulier verwerkt hebben, is een goede basis. Er zijn uiteraard andere manieren, maar dit vind ik persoonlijk de meest veilige, flexibele en fijne manier om de verwerking van een formulier af te handelen.

Uitbreiden van het formulier
Nu we de basis van het verwerken van een forumlier gezien hebben, kunnen we het formulier wat uitbreiden. Laten we een mogelijkheid tot het invullen van een geboorte datum toevoegen. Het formulier komt er dan zo uit te zien:
[code=formulier2.php]
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">;
<html xmlns="http://www.w3.org/1999/xhtml">;
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Mijn eerste formulier!</title>
</head>

<body>
<form action="verwerk2.php" method="post">
<p>
<label for="voornaam">Voornaam:</label>
<input type="text" name="voornaam" id="voornaam" />
</p>
<p>
<label for="achternaam">Achternaam:</label>
<input type="text" name="achternaam" id="achternaam" />
</p>
<p>
<label>Geboortedatum:</label>
<select name="dag">
<?php
for($i = 1; $i <= 31; $i++)
{

echo '<option value="'.$i.'">'.$i.'</option>';
}
?>
</select>
<select name="maand">
<?php
for($i = 1; $i <= 12; $i++)
{
echo '<option value="'.$i.'">'.$i.'</option>';
}
?>
</select>
<select name="jaar">
<?php
for($i = date('Y'); $i >= 1950; $i--)
{
echo '<option value="'.$i.'">'.$i.'</option>';
}
?>
</select>
</p>
<p>
<input type="submit" value="Verzenden" />
</p>
</form>
</body>
</html>
[/code]
We zien dat er wat extra velden bijgekomen zijn en dat er nu ook wat PHP code in het formulier verwerkt zit. Ik wil voor het invoeren van de geboortedatum namelijk drie <select> boxjes gebruiken voor repectievelijk de dag, de maand en het jaar.

Nu zouden we natuurlijk alle opties handmatig in HTML kunnen gaan invoeren (31 dagen, 12 maanden, 58 jaren) maar dat zou natuurlijk niet echt slim zijn. We hebben immers de beschikking over PHP die zoiets heel eenvoudig voor ons kan genereren. Met een drietal for-loopjes is dat probleem zo opgelost.

De eerste twee loopjes spreken voor zich. In de derde for loop tellen we nu een keer af in plaats van op. We gaan nu dus vanaf het huidige jaar, dat we bepalen met behulp van de date() functie, aftellen tot aan het jaar 1950. Vandaar dat we ook $i-- gebruiken om de waarde van $i telkens met 1 te verlagen.

Hier kun je wederom een werkend voorbeeld vinden.

Verwerking van het uitgebreide formulier
We hebben nu een nieuw element aan ons formulier toegevoegd, dus de verwerking van het formulier moeten we ook aanpassen. Deze komt er als volgt uit te zien:
[code=verwerk2.php]
<?php
include '../../inc/stats.php';
// Controle of een formulier gepost is
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
// Arrays declareren voor opslag van fouten en data
$aErrors = array();
$aData = array();

// Velden die in het formulier aanwezig moeten zijn
$aFormulierVelden = array(
'voornaam',
'achternaam',
'dag',
'maand',
'jaar'
);

// Waarden uit de $_POST array doorlopen
foreach($aFormulierVelden as $sVeld)
{
if(isset($_POST[$sVeld]))
{
// Spaties aan begin en eind weghalen
$sValue = trim($_POST[$sVeld]);

// Controle of variabele gevuld is
if(empty($sValue))
{
// Foutmelding toevoegen
$aErrors[] = 'Je bent vergeten om '.$sVeld.' in te vullen';
}

// Ingevulde waarden aan data array toevoegen
$aData[$sVeld] = $sValue;
}
else
{
$aErrors[] = 'Het veld '.$sVeld.' is niet gepost!';
}
}

// Datum controle
if(isset($aData['maand'], $aData['dag'], $aData['jaar']) && checkdate($aData['maand'], $aData['dag'], $aData['jaar']))
{
$sDatum = $aData['dag'].'-'.$aData['maand'].'-'.$aData['jaar'];
}
else
{
$aErrors[] = 'Dit is geen geldige datum';
}

// Controleren of er geen fouten opgetreden zijn
if(empty($aErrors))
{
// Formulier succes!
echo '<p>Je hebt het formulier succesvol ingevuld! De volgende gegevens zijn bekend:</p>';
echo '<p>Voornaam: '.$aData['voornaam'].'<br />';
echo 'Achternaam: '.$aData['achternaam'].'</p>';
echo '<p>Geboortedatum: '.$sDatum.'</p>';
}
else
{
// Fouten opgetreden: weergeven en terug naar formulier
header('Refresh: 3; url=formulier2.php');
foreach($aErrors as $sError)
{
echo '<p style="color:red">'.$sError.'</p>';
}
}
}
else
{
// Verwerk.php mag nog niet bezocht worden, terug naar het formulier
header('Location: formulier2.php');
}
?>
[/code]
We zien dat de verwerking eigenlijk bijna hetzelfde is, op een paar kleine veranderingen na. Allereerst zijn de verwijzingen naar formulier.php natuurlijk veranderd in formulier2.php.

Daarnaast heb ik nu een controle ingebouwd die controleert of de ingevulde datum wel geldig is.

<?php
if(isset($aData['maand'], $aData['dag'], $aData['jaar']) && checkdate($aData['maand'], $aData['dag'], $aData['jaar']))
{
	$sDatum = $aData['dag'].'-'.$aData['maand'].'-'.$aData['jaar'];
}
else
{
	$aErrors[] = 'Dit is geen geldige datum';
}

Allereerst controleren we met isset() of de benodigde variabelen wel voorkomen in de $aData array, en of ze dus wel in het formulier voorkomen. De functie checkdate() wordt vervolgens gebruikt om de geldigheid van een ingevoerde datum te controleren. Deze functie accepteert 3 parameters, in volgorde: een maand, dag en jaar. Vervolgens wordt een boolean terug gegeven of de datum geldig is of niet. Op deze manier is het dus niet mogelijk om bijvoorbeeld een datum als 31 februari 2008 te selecteren.

Als de controle van de datum slaagt, voegen we de verschillende onderdelen samen in een variabele $sDatum. Zo niet, dan voegen we een foutmelding toe aan de array $aErrors.

De laatste kleine verandering bevindt zich in de verwerking van de gecontroleerde gegevens. Naast de voor- en achternaam, wordt nu ook de ingevulde geboortedatum op het scherm getoond.

Tot zover het maken en verwerken van formulieren in deze tutorial. Mocht je nog andere voorbeelden willen bekijken, dan verwijs ik je graag door naar een van de volgende scripts:

[li]Uitgebreide formuliercontrole[/li]
[li]Contactformulier met Swift Mailer[/li]


Deze voorbeelden zijn een stuk uitgebreider en laten zien wat er onder andere ook mogelijk is op het gebied van formulier controle en verwerking.

PHP kent enkele vooraf gedefinieerde variabelen, de zogenaamde superglobals. Deze variabelen zijn arrays die afhankelijk van de situatie allerlei waarden kunnen bevatten. Deze superglobals zijn overal en in elk script beschikbaar. Dit wil echter niet zeggen dat ze ook altijd gevuld zijn, dat hangt van de situatie af.

De superglobals waarin ik in deze tutorial aandacht zal besteden zijn:

[li]$_GET[/li]
[li]$_POST[/li]
[li]$_FILES[/li]
[li]$_SERVER[/li]
[li]$_COOKIE[/li]
[li]$_REQUEST[/li]

Naast deze lijst zijn er nog twee variabelen: $_ENV en $GLOBALS. Deze gebruik je echter (bijna) nooit, dus daar zal ik hier verder ook geen aandacht aan besteden.

Als we naar het lijstje kijken zien we dat we twee van deze variabelen al gebruikt hebben. $_SERVER en $_POST kwamen namelijk al eerder in het verwerkingsscript van ons formulier tegen. Nu zal ik de uitleg achter de werking van deze variabelen geven.

$_GET
Iedereen heeft wel eens een url van een website gezien die er bijvoorbeeld zo uit zag: [ignore]http://www.eensite.nl/index.php?show=bericht&id=10[/ignore]. Wellicht dat je je ook ooit al eens afgevraagd hebt wat die ? en & in de url nou precies doen en dat je al een vermoeden had dat dit variabelen zijn. Dan zat je helemaal op het juiste spoor. Deze zogenaamde GET variabelen zijn variabelen die aan de url meegegeven kunnen worden en die we later in ons script kunnen gebruiken. In bovenstaand voorbeeld heb je dus beschikking over de GET variabelen 'show' en 'id'.

In ons script zijn deze variabelen te vinden in de superglobal $_GET. Deze variabele is een array waarin alle variabelen uit de url opgeslagen zijn. Met het volgende scriptje in onze index.php zal ik laten zien hoe dit werkt:
[code=index.php]
<?php
if(isset($_GET['naam'], $_GET['leeftijd']))
{
echo 'Hoi '.$_GET['naam'].', jij bent '.$_GET['leeftijd'].' jaar.';
}
else
{
echo 'Een van de benodigde GET variabelen bestaat niet';
}
?>
[/code]
Als we het script nu aan zouden roepen met de volgende url: index.php?naam=Kees&leeftijd=42, zou dat de volgende output geven:

Hoi Kees, jij bent 40 jaar.

Allereerst controleren we met isset() of de twee GET variabelen wel bestaan. Dit moeten we altijd doen met variabelen die uit de url komen, het wordt namelijk lastig werken met variabelen die niet bestaan. Vervolgens gebruiken we de variabelen om wat informatie op het scherm te zetten.

Om te laten zien dat de controle of de variabelen bestaan werkt, roepen we de pagina nu als volgt aan: index.php?naam=Kees. Dit is de output die we nu krijgen:

Een van de benodigde GET variabelen bestaat niet

$_POST
De werking van deze variabele hebben we in het vorige hoofdstuk al kunnen aanschouwen. Kort gezegd bevat deze variabele de waarden die met behulp van een formulier gepost zijn. Een formulier met als method 'post' is tevens ook de enige manier om deze variabele te vullen.

In het vorige hoofdstuk staat een uitgebreid voorbeeld van de werking van deze superglobal, dus ik ga hier niet nog eens een voorbeeld geven. Wij gaan snel door met de volgende superglobal.

$_FILES
Zoals je wellicht wel weet is het met een combinatie van HTML en PHP ook mogelijk om bestanden naar de webserver te uploaden. Denk bijvoorbeeld aan het toevoegen van een bijlage aan je webmail of het toevoegen van een filmpje op youtube.

Om bestanden te kunnen uploaden heb je in je formulier een veld van het type 'file' nodig. Bovendien moet je ervoor zorgen dan je ook het 'enctype' attribuut aan de <form> tag meegeeft met de waarde 'multipart/form-data'.

<?php
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
	echo '<pre>'.print_r($_FILES, true).'</pre>';
}
?>

<form action="#" method="post" enctype="multipart/form-data">
<p>
	<label for="userfile">Bestand:</label>
	<input type="file" name="userfile" id="userfile" />
</p>
<p>
	<input type="submit" value="Uploaden" />
</p>
</form>

Hier zien we een voorbeeld van een formuliertje om een bestand te uploaden. Als action heb ik dit keer een # ingevuld, dan worden de waarden uit het formulier naar dezelfde pagina gestuurd. Verder zien we dat de method weer op 'post' staat en dat we nu een enctype meegegeven hebben.

Omdat het formulier de waarden naar dezelfde pagina verstuurd, zien we ook dat de verwerking van het formulier in dit scriptje staat. In dit geval bestaat het uit niet meer dan het weergeven de de inhoud van $_FILES op het scherm.

Een voorbeeld van output na uploaden van een bestand zou de volgende kunnen zijn:

Array
(
    [userfile] => Array
        (
            [name] => sprinkhaan.jpg
            [type] => image/jpeg
            [tmp_name] => C:\wamp\tmp\phpD23E.tmp
            [error] => 0
            [size] => 45194
        )
)

We zien dat $_FILES een multidimensionale associatieve array is. De eerste sleutel bevat de naam van het input veld waarin we de bestandsnaam kozen. De waarde die bij deze sleutel hoort is weer een array met gegevens over het bestand dat geupload is. Een kort overzichtje:

[li]name - De bestandsnaam van het geuploade bestand[/li]
[li]type - Het MIME type van het bestand. Dit geeft aan wat voor soort bestand het is[/li]
[li]tmp_name - Elk geupload bestand komt in de tmp map onder een tijdelijke naam te staan[/li]
[li]error - Normaal gesproken 0, een andere waarde als het uploaden niet lukt[/li]
[li]size - De bestandsgrootte in bytes[/li]

Nu heb ik het telkens over het bestand dat geupload is, maar in werkelijkheid is dat nog niet het geval. Het is door de HTML code van jouw computer naar een tijdelijke locatie verhuist. Nu zul je met PHP het uploaden van het bestand af moeten ronden.

Dit hoort echter niet tot de onderwerpen die ik in deze tutorial behandel. Wil je hier meer over lezen, dan vind je hier een duidelijk en veilig voorbeeld.

$_SERVER
Ook van deze superglobal hebben we in het vorige hoofdstuk gebruik gemaakt. In deze variabele is informatie over de server en de manier waarop met de server gecommuniceerd is, opgeslagen. Laten we eens kijken wat we er allemaal in vinden:

<?php
echo '<pre>'.print_r($_SERVER, true).'</pre>';
?>

Array
(
    [HTTP_HOST] => localhost
    [HTTP_USER_AGENT] => Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.8.1.11) Gecko/20071127 Firefox/2.0.0.11
    [HTTP_ACCEPT] => text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
    [HTTP_ACCEPT_LANGUAGE] => en-gb,en;q=0.5
    [HTTP_ACCEPT_ENCODING] => gzip,deflate
    [HTTP_ACCEPT_CHARSET] => ISO-8859-1,utf-8;q=0.7,*;q=0.7
    [HTTP_KEEP_ALIVE] => 300
    [HTTP_CONNECTION] => keep-alive
    [HTTP_COOKIE] => mtrack=119762117M1932826833; PHPSESSID=g5fiq9d9udq9vanpvuosb0dsn4
    [PATH] => C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\Program Files\ATI Technologies\ATI Control Panel;C:\Program Files\QuickTime\QTSystem\;C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
    [SystemRoot] => C:\WINDOWS
    [COMSPEC] => C:\WINDOWS\system32\cmd.exe
    [PATHEXT] => .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH
    [WINDIR] => C:\WINDOWS
    [SERVER_SIGNATURE] => 
    [SERVER_SOFTWARE] => Apache/2.2.6 (Win32) PHP/5.2.5
    [SERVER_NAME] => localhost
    [SERVER_ADDR] => 127.0.0.1
    [SERVER_PORT] => 80
    [REMOTE_ADDR] => 127.0.0.1
    [DOCUMENT_ROOT] => C:/wamp/www/
    [SERVER_ADMIN] => webmaster@localhost
    [SCRIPT_FILENAME] => C:/wamp/www/index.php
    [REMOTE_PORT] => 4819
    [GATEWAY_INTERFACE] => CGI/1.1
    [SERVER_PROTOCOL] => HTTP/1.1
    [REQUEST_METHOD] => GET
    [QUERY_STRING] => 
    [REQUEST_URI] => /index.php
    [SCRIPT_NAME] => /index.php
    [PHP_SELF] => /index.php
    [REQUEST_TIME] => 1199267859
)

Ik zal niet elke waarde uit deze array bespreken, enkel de variabelen die je regelmatig gebruikt zal ik kort toelichten.

[li]HTTP_HOST - Geeft de hostnaam weer. Dus bijvoorbeeld 'localhost' of 'phphulp.jorendewit.nl'[/li]
[li]REMOTE_ADDR - Het ip adres van de bezoeker van het script[/li]
[li]DOCUMENT_ROOT - Geeft het pad waarin het script zich bevind, relatief vanaf de root van de server[/li]
[li]REQUEST_METHOD - Geeft de manier waarop de pagina is aangeroepen. Meestal GET of POST.[/li]
[li]REQUEST_URI - De url waarmee het script aangeroepen is, inclusief GET variabelen[/li]
[li]SCRIPT_NAME - De bestandsnaam van het uitgevoerde script[/li]

De variabelen uit deze array gebruik je in de meeste gevallen om bijvoorbeeld te controleren of een formulier gepost is, te controleren hoe het script aangeroepen is, of om gegevens over de bezoeker te achterhalen. Meestal kun je variabelen uit deze array wel combineren tot een gewenst resultaat.

$_SESSION
We hebben nu de werking van onder andere de $_GET en $_POST superglobal gezien, en hoe we daarmee variabelen van buitenaf in een script kunnen krijgen. Maar wellicht dat je je wel eens afgevraagd hebt of er niet een manier is om variabelen beschikbaar te maken op een pagina zonder dat je deze via een formulier verstuurd of in de url zet.

Dat is nou precies waar je binnen PHP een sessievariabele voor kunt gebruiken. Deze kun je aanmaken op pagina1 en vervolgens op pagina2 weer uitlezen. De voorwaarde is dat je elke pagina waarop je sessievariabelen wilt gebruiken, begint met session_start(). Sessievariabelen worden tijdelijk opgeslagen op de server en zijn te gebruiken met de superglobal $_SESSION.
[code=pagina1.php]
<?php
// Elke pagina waar we sessies gebruiken, beginnen met met session_start()
session_start();

// Declareren van sessievariabelen
$sNaam = 'Kees';
$_SESSION['naam'] = $sNaam;
$_SESSION['leeftijd'] = 42;
?>
[/code][code=pagina2.php]
<?php
// Elke pagina waar we sessies gebruiken, beginnen met met session_start()
session_start();

// Uitlezen van de sessievariabele
echo 'Hoi '.$_SESSION['naam'].' jij bent '.$_SESSION['leeftijd'].' jaar';
?>
[/code]

Hoi Kees jij bent 42 jaar

Een sessievariabele zal beschikbaar zijn, zolang de sessie nog actief is. Hoe lang dat is, is afhankelijk van de instellingen van de server. Het zou bijvoorbeeld 1 dag kunnen zijn, maar het is ook mogelijk dat de sessie bij het afsluiten van de browser al gesloten wordt.

In het volgende hoofdstuk zal ik dieper ingaan op het gebruik van sessievariabelen en zullen we een eerste loginscriptje schrijven.

$_COOKIE
Naast het gebruik van sessievariabelen om gegevens op meerdere paginas te kunnen gebruiken, kent PHP ook het gebruik van cookies voor dit doeleinde. Het verschil met sessievariabelen is dat cookies op de PC van de bezoeker opgeslagen worden. Ze kunnen dus handmatig verwijderd en gewijzigd worden en derhalve is het niet veilig om er gevoelige informatie in te zetten.

Cookies aanmaken
Het aanmaken van een cookie doen we met de functie setcookie().
[code=pagina1.php]
<?php
// De naam die we in een cookie op willen slaan.
$sNaam = 'Kees';

// Het aanmaken van de cookie met setcookie()
setcookie('cookieNaam', $sNaam, time()+3600);
?>
[/code]
De eerste parameter van de setcookie() functie is de naam van de cookie. Daaraan kunnen we hem straks herkennen. Daarna volgt de inhoud van de cookie, in dit geval de naam, en tenslotte geven we het tijdstip waarop de cookie moet verlopen, op. Een cookie is net als een sessie namelijk maar een bepaalde tijd geldig, in dit geval dus een uur.

Uitlezen van de cookie
Voor het uitlezen van de cookie kunnen de de superglobal $_COOKIE gebruiken.
[code=pagina2.php]
<?php
echo 'Welkom terug '.$_COOKIE['cookieNaam'];
?>
[/code]

Welkom terug Kees

Cookies gebruik je in de meeste gevallen om specifieke instellingen van een gebruiker langere tijd te bewaren. Bijvoorbeeld het automatisch inloggen als een gebruiker op een website terugkeert, wordt door middel van cookies gedaan.

$_REQUEST
De laatste superglobal die ik wil bespreken is $_REQUEST. Deze superglobal bevat een combinatie van de $_GET. $_POST en $_COOKIE arrays. In plaats van een voorbeeld te geven, wil ik het gebruik van deze juist variabele afraden.

Deze variabele heeft totaal geen meerwaarde boven de losse superglobals en kan alleen maar voor verwarring zorgen. Met deze superglobal weet je namelijk niet meer niet meer of een waarde nu uit de GET, POST of COOKIE array afkomstig is. Naast onduidelijkheid kan dit ook een potentieel veiligheidslek met zich meebrengen. Gewoon niet gebruiken dus.

In het vorige hoofdstuk hebben we een uitleg van het gebruik van superglobals in PHP gezien. Ook hebben we daar kennis gemaakt met de $_SESSION superglobal waarmee we variabele op meerdere paginas beschikbaar konden maken.

We zullen nu kijken naar hoe we deze manier kunnen toepassen in een zeer eenvoudig loginscript. Het script dat we schrijven is een loginscript voor 1 gebruiker met wachtwoord en zal gebruik maken van sessies.

De HTML code
Laten we maar weer beginnen met de HTML code van het loginformulier. We hebben nu twee inputvelden nodig waarin we een gebruikersnaam en wachtwoord in kunnen vullen. De typen die we voor deze velden gebruiken zijn respectievelijk 'text' en 'password'.
[code=login_form.php]
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">;
<html xmlns="http://www.w3.org/1999/xhtml">;
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Mijn eerste loginscript!</title>
</head>

<body>
<h1>Inloggen</h1>
<form method="post" action="login.php">
<p>
<label for="user">Gebruikersnaam:</label>
<input type="text" name="user" id="users" />
</p>
<p>
<label for="pass">Wachtwoord:</label>
<input type="password" name="pass" id="pass" />
</p>
<p>
<input type="submit" value="Inloggen" />
</p>
</form>
</body>
</html>
[/code]
Deze code spreekt redelijk voor zich. De action van het formulier laten we verwijzen naar login.php, het script waarmee we het login formulier verwerken.

Hier kun je een werkend voorbeeld van het loginscript vinden.

Het PHP script
Ook nu zal ik eerst weer het hele script laten zien, waarna ik het stap voor stap met je zal doornemen.
[code=login.php]
<?php
include '../../inc/stats.php';
// We gaan sessies gebruiken
session_start();

// Gebruikersnaam en wachtwoord instellen
$sGebruikerControle = 'admin';
$sWachtwoordControle = 'voorbeeld';

// Controle of het formulier verzonden is
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
// Controle of benodigde velden wel ingevuld zijn
if(isset($_POST['user'], $_POST['pass']))
{
// Overbodige spaties verwijderen
$sGebruiker = trim($_POST['user']);
$sWachtwoord = trim($_POST['pass']);

// Gebruikersnaam en wachtwoord controleren
if($sGebruiker == $sGebruikerControle && $sWachtwoord == $sWachtwoordControle)
{
// Juiste gebruikersnaam en wachtwoord: inloggen!
$_SESSION['logged_in'] = true;
$_SESSION['gebruiker'] = $sGebruiker;

// Doorsturen en melding geven
header('Refresh: 3; url=beveiligd.php');
echo 'Je bent succesvol ingelogd. Je wordt doorgestuurd.';
}
else
{
// Terugsturen en foutmelding geven
header('Refresh: 3; url=login_form.php');
echo 'Deze combinatie van gebruikersnaam en wachtwoord is niet juist!';
}
}
else
{
header('Refresh: 3; url=login_form.php');
echo 'Een vereist veld bestaat niet!';
}
}
else
{
// Terug naar het formulier
header('Location: login_form.php');
exit();
}
?>
[/code]
Zoals je ziet lijkt het redelijk veel op de afhandeling van een formulier die we eerder al toegepast hebben. In dit script zitten echter wel een aantal andere dingen.

<?php
// We gaan sessies gebruiken
session_start();

// Gebruikersnaam en wachtwoord instellen
$sGebruikerControle = 'admin';
$sWachtwoordControle = 'voorbeeld';
?>

We maken bij dit loginscript gebruik van sessievariabelen, dus moeten we de pagina met session_start() beginnen. Vervolgens declareren we twee variabelen die respectievelijk de gebruikersnaam en het wachtwoord bevatten, deze zullen we later voor de controle gebruiken.

In geavanceerdere loginscripts haal je de gebruikersnaam en wachtwoord voor controle vaak uit een database. Maar aangezien database verbindingen geen onderdeel van deze tutorial zijn, zal ik dat hier niet behandelen.

<?php
// Controle of het formulier verzonden is
if($_SERVER['REQUEST_METHOD'] == 'POST')
?>

Ook hier controleren we eerst of er wel een formulier gepost is. We kunnen immers alleen met $_POST variabelen werken als ze ook daadwerkelijk gevuld en dus verzonden zijn.

<?php
// Controle of benodigde velden wel ingevuld zijn
if(isset($_POST['user'], $_POST['pass']))
?>

De controle of de benodigde velden wel in de $_POST array aanwezig zijn, kan hier natuurlijk ook niet ontbreken.

<?php
// Overbodige spaties verwijderen
$sGebruiker = trim($_POST['user']);
$sWachtwoord = trim($_POST['pass']);
?>

Vervolgens gebruiken we trim() om de loze spaties voor of achter een input te verwijderen. Dit voorkomt dat de gebruikersnaam en wachtwoord niet overeen zouden komen door zo'n spatie.

<?php
if($sGebruiker == $sGebruikerControle && $sWachtwoord == $sWachtwoordControle)
{
	// Juiste gebruikersnaam en wachtwoord: inloggen!
	$_SESSION['logged_in'] = true;
	$_SESSION['gebruiker'] = $sGebruiker;
	
	// Doorsturen en melding geven
	header('Refresh: 3; url=beveiligd.php');
	echo 'Je bent succesvol ingelogd. Je wordt doorgestuurd.';
}
?>

Dit is het gedeelte waar het eigenlijk om draait. Allereerst controleren we of de ingevulde gebruikersnaam en wachtwoord overeenkomen met de ingestelde waarden. Als dat het geval is, declareren we een tweetal sessievariabelen. $_SESSION['logged_in'] is een boolean die aangeeft of een gebruiker ingelogd is, $_SESSION['gebruiker'] krijgt de gebruikersnaam van de ingelogde gebruiker.

Opmerking: wachtwoorden sla je nooit op in een sessievariabele of cookie. Dit is nergens voor nodig en bovendien onveilig aangezien ook sessies gestolen kunnen worden. Een wachtwoord heb je maar eenmalig nodig, en dat is bij de controle van het login formulier.

Tenslotte geven we een melding dat de gebruiker ingelogd is en sturen we de gebruiker door naar de volgende pagina.

<?php
else
{
	// Terugsturen en foutmelding geven
	header('Refresh: 3; url=login_form.php');
	echo 'Deze combinatie van gebruikersnaam en wachtwoord is niet juist!';
}
?>

Als de gebruikersnamen en/of het wachtwoord niet overeenkomen, geven we daar een melding van en sturen we de gebruiker terug naar het login formulier.

De beveiligde pagina
Tot nu toe hebben we gezien hoe we het login formulier in HTML weergeven en hoe de verwerking van het login formulier eruit ziet. Dan kunnen we nu kijken naar de beveiligde paginas die alleen toegankelijk zijn voor ingelogde gebruikers.

Op deze beveiligde paginas controleren we helemaal aan het begin met een if-statement of de bezoeker wel ingelogd is. Als dat niet het geval is, sturen we hem direct door naar het login formulier en stoppen we de rest van de uitvoer van het script.
[code=beveiligd.php]
<?php
// We werken ook hier met sessies
session_start();

// Controleren of de bezoeker ingelogd is
if(!isset($_SESSION['logged_in']) || $_SESSION['logged_in'] == false)
{
header('Location: login_form.php');
exit();
}

// Een welkomst tekst weergeven
echo 'Welkom '.$_SESSION['gebruiker'].' wat leuk dat je er weer bent.';
?>
[/code]
Allereerst beginnen we deze pagina ook weer met session_start(), we werken immers weer met sessievariabelen. Vervolgens controleren we of de variabele $_SESSION['logged_in'] bestaat en of de waarde van deze variabele niet gelijk is aan FALSE.

Als een van deze voorwaarden wel het geval is, sturen we de gebruiker met een header() direct door naar het login formulier en gebruiken we exit() om de verdere uitvoer van het script te stoppen.

Mocht de bezoeker wel ingelogd zijn, dan wordt niet voldaan aan het if-statement en wordt de rest van het script uitgevoerd. In ons geval houdt dat het geven van een welkomstbericht in. In dat bericht gebruiken we $_SESSION['gebruiker'] om de ingelogde gebruiker persoonlijk aan te spreken.

Op elke pagina waarop je enkel ingelogde gebruikers toegang wilt geven, plaats je dus regel 1-10 uit dit voorbeeld boven aan het script. Op die manier heb je altijd de zekerheid dat de pagina alleen aan ingelogde gebruikers getoond wordt.

Hier kun je een werkend voorbeeld van het loginscript vinden. De gebruikersnaam en wachtwoord zijn, zoals je in het script kunt zien, admin en voorbeeld.

Het einde van deze tutorial begint in zicht te komen. Er zijn echter nog een paar zaken waaraan ik aandacht wil besteden. Deze laatste twee hoofdstukken zullen in het tekenstaan van de manier waarop je scripts op bouwt en het oplossen van fouten in een script aan de hand van foutmeldingen (debuggen).

Het netjes opbouwen van je PHP scripts is belangrijk. Allereerst omdat je zo het overzicht over je code behoudt. Vooral naarmate je code langer wordt, kan hij wel eens heel overzichtelijk worden als je niet op een nette manier script. Daarnaast zullen we zien dat het oplossen van fouten veel makkelijker wordt als je scripts netjes opgebouwd zijn.

Inspringen
Een eenvoudige methode om je code overzichtelijk te houden is door op vaste plaatsen en consequent in te springen. Kijk eens naar het volgende stukje code:

<?php
if($_SERVER['REQUEST_METHOD'] == 'POST'){
$aErrors = array();
$aData = array();
foreach($_POST as $sKey => $sValue){
$sValue = trim($sValue);
if(empty($sValue)){
$aErrors[] = 'Je bent vergeten om '.$sKey.' in te vullen';
}
$aData[$sKey] = $sValue;
}
if(empty($aErrors)){
echo '<p>Je hebt het formulier succesvol ingevuld! De volgende gegevens zijn bekend:</p>';
echo '<p>Voornaam: '.$aData['voornaam'].'<br />';
echo 'Achternaam: '.$aData['achternaam'].'</p>';
}else{
header('Refresh: 3; url=formulier.php');
foreach($aErrors as $sError){
echo '<p style="color:red">'.$sError.'</p>';
}
}
}
?>

Dit is een werkend stukje code en als we goed kijken zien we dat dit een deel uit het verwerkingsscript van ons eerste formulier is. Alleen heb ik nu alle 'overbodig' tabs en enters uit het script gehaald. Vergelijk dit nu eens met de originele code:

<?php
if($_SERVER['REQUEST_METHOD'] == 'POST')
{
    // Arrays declareren voor opslag van fouten en data
    $aErrors = array();
    $aData = array();
    
    // Waarden uit de $_POST array doorlopen
    foreach($_POST as $sKey => $sValue)
    {
        // Spaties aan begin en eind weghalen
        $sValue = trim($sValue);
        
        // Controle of variabele gevuld is
        if(empty($sValue))
        {
            // Foutmelding toevoegen
            $aErrors[] = 'Je bent vergeten om '.$sKey.' in te vullen';
        }
        
        // Ingevulde waarden aan data array toevoegen
        $aData[$sKey] = $sValue;
    }
    
    // Controleren of er geen fouten opgetreden zijn
    if(empty($aErrors))
    {
        // Formulier succes!
        echo '<p>Je hebt het formulier succesvol ingevuld! De volgende gegevens zijn bekend:</p>';
        echo '<p>Voornaam: '.$aData['voornaam'].'<br />';
        echo 'Achternaam: '.$aData['achternaam'].'</p>';
    }
    else
    {
        // Fouten opgetreden: weergeven en terug naar formulier
        header('Refresh: 3; url=formulier.php');
        foreach($aErrors as $sError)
        {
            echo '<p style="color:red">'.$sError.'</p>';
        }
    }
}
?>

Volgens mij kun je niet anders dan het met me eens zijn, dat dit een stuk duidelijker en overzichtelijker is. Dit wordt voornamelijk veroorzaakt door het op een consequente manier inspringen. De manier die ik altijd gebruik is de volgende:

<?php
if( statement )
{
    // Doe iets
    while( statement)
    {
        //Doe nog iets
    }
}
else
{
    // Doe iets anders
}
?>

Een andere standaard die ook veel gebruikt wordt is de volgende:

<?php
if( statement ) {
    // Doe iets
    while( statement) {
        //Doe nog iets
    }
} else {
    // Doe iets anders
}
?>

Deze methode is korter maar vind ik persoonlijk minder fijn werken. De keuze van de manier van inspringen is heel persoonlijk en je hoeft je ook niet per se aan een algemene standaard te houden. Het belangrijkste is dat je 1 methode kiest en die vervolgens consequent toepast.

Ook als je stukjes code kopieert (wat ik zelf ook regelmatig doe), verander dan de layout ervan naar je eigen methode, zodat de code netjes in de rest van je script pas.

Commentaar
Ik heb het al eerder in deze tutorial gezegd, maar het toevoegen van commentaar is ook belangrijk om het overzicht te behouden. Niet alleen voor anderen maar ook voor jezelf. Vooral als je code langer wordt is het belangrijk om commentaar toe te voegen aan de verschillende elementen in je code. Op die manier weten anderen en jijzelf later nog wat de functie van een bepaald onderdeel ook alweer was.

Zorg dat je commentaar op nuttige plaatsen toepast, te veel is namelijk ook niet goed. Ga dus niet aan elk if en else statementje een regel commentaar toevoegen als de functie ervan ook zonder commentaar duidelijk is. Dit zal er alleen maar voor zorgen dat je code weer onoverzichtelijker wordt, en dat moet je zien te voorkomen.

Een belangrijk aspect van het programmeren waarmee ik deze tutorial wil afsluiten, is het debuggen van je scripts. Alle programmeur zijn mensen en mensen maken fouten. We kunnen dus ook niet voorkomen dat er foutjes in onze scripts sluipen waardoor een script niet zal werken.

Dit hoeft echter helemaal geen probleem te zijn, aangezien je fouten kunt oplossen. Het debuggen van je script bestaat dan ook uit 3 stappen:

[li]Constateren van een fout[/li]
[li]De fout lokaliseren in je script[/li]
[li]Oplossen van de fout[/li]

Voordat we hier echter mee beginnen, eerst iets anders. We willen immers wel dat PHP ook daadwerkelijk foutmeldingen gaat geven als er iets fout gaat. Daarom zetten we van nu af aan altijd deze twee regels boven aan onze php scripts:

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);
?>

De eerste regel zorgt ervoor dat fouten überhaupt weergegeven worden, terwijl de tweede regel ervoor zorgt dat alle mogelijke foutmeldingen op het scherm getoond worden.

Regels toegevoegd maar geen fouten te zien?
Het kan zijn dat de display_errors instelling in de php.ini uitgeschakeld staat. Hoewel we hem in ons script met ini_set() aan zetten, wordt dit pas gedaan als het script uitgevoerd wordt. Eventuele syntax fouten in het script worden dus nog niet weergegeven.

Om dat voor elkaar te krijgen, plaatsen we een .htaccess bestandje met de volgende regels in de root (public_html, www of htdocs map) van onze website:

# Display Errors inschakelen
php_flag display_errors on

Nu worden alle foutmeldingen netjes op het scherm getoond.

Debuggen
Ik zal een aantal voorbeelden geven van de meest voorkomende fouten in een PHP script. Bij elk voorbeeld zullen we vervolgens aan de hand van de drie stappen van het debuggen de fout proberen te verhelpen.

De eerste stap, het constateren van de fout, is de minst lastige. PHP zal namelijk een foutmelding op het scherm zetten en al dan niet het script stoppen. De syntax van de standaard PHP foutmelding ziet er er als volgt uit:

[fout level]: [bericht] in [bestand] on line [regelnummer]

De tweede stap zal in de meeste gevallen de lastigste zijn. In de foutmelding wordt altijd een bestand en regelnummer gegeven waar de fout optreedt. Dat geeft ons een indicatie van waar iets fout gaat en gecombineerd met het bericht leidt ons dat meestal wel naar de fout.

De derde stap is weer heel eenvoudig. Immers, als je weet wat er fout gaat, kun je het ook heel eenvoudig oplossen.

Debuggen is een techniek die je jezelf moet aanleren. Goed kunnen debuggen zul je niet in 1x kunnen, daar komt ook een stukje ervaring bij kijken. Laten we daarom gewoon maar eens beginnen en naar wat veel voorkomende fouten en oplossingen kijken.

Parse error

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

$sNaam = 'Kees'
echo $sNaam;
?>

Parse error: syntax error, unexpected T_ECHO in C:\wamp\www\fouten.php on line 6

Deze foutmelding geeft aan dat we een fout in de syntax van ons script hebben, en wel op regel 6 in fouten.php. PHP geeft aan dat hij een bepaald element niet verwacht: 'syntax error, unexpected T_ECHO'. Met andere woorden, de echo op regel 6 komt onverwacht.

Om de fout te lokaliseren zullen we vanaf regel 6 terug moeten gaan kijken, op zoek naar de reden waarom de echo onverwacht is. In veel gevallen zal het zo zijn dat je ergens een punt-komma, quote of haakje vergeten bent.

De fout is hier snel gevonden, we zien namelijk dat we vergeten zijn om regel 5 met een punt-komma af te sluiten. De oplossing is dus het plaatsen van de punt-komma.

PHP zal altijd aangeven welk element niet verwacht wordt. Soms wordt het teken weergeven, soms een omschrijving. Enkele omschrijvingen die je regelmatig ziet:

[li]T_VARIABELE - Een variabele[/li]
[li]T_IS_EQUAL - Een == teken[/li]


Undefined variable

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

echo $sNaam;
?>

Notice: Undefined variable: sNaam in C:\wamp\www\fouten.php on line 5

Deze foutmelding vertelt ons dat er op regel 5 in fouten.php iets fout gegaan is. Het bericht 'Undefined variable: sNaam' houdt in dat we een variabele $sNaam gebruikt hebben die niet bestaat. De oplossing is dus ofwel het eerder declareren van deze variabele, ofwel eerst controleren of deze variabele bestaat voordat we hem gebruiken:

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

$sNaam = 'Kees';
echo $sNaam;
?>

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

if(isset($sNaam))
{
	echo $sNaam;
}
?>

Undefined index

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

echo $_GET['naam'];
?>

Notice: Undefined index: naam in C:\wamp\www\fouten.php on line 5

De undefined index is bijna hetzelfde als de undefined variabele. Deze foutmelding wordt namelijk weergegeven als een bepaalde sleutel in een array niet bestaat. De oplossing is hier wederom het eerst controleren of de variabele bestaat voordat je hem gebruikt:

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

if(isset($_GET['naam']))
{
	echo $_GET['naam'];
}
?>

Parse errors: unexpected $end

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

if(isset($_GET['naam']))
{
	echo $_GET['naam'];
?>

Parse error: syntax error, unexpected $end in C:\wamp\www\fouten.php on line 10

Dit zijn meestal vervelendere fouten om op te moeten lossen. Met name omdat deze fout altijd plaatsvindt op de laatste regel van je script.

De oorzaak is bijna altijd dat het aantal { niet gelijk is aan het aantal } in je script waardoor er dus bepaalde constructies niet afgesloten zijn. In het voorbeeld is direct duidelijk dat we de } van het if-statement vergeten zijn. Maar naarmate je code langer wordt, kan dit een ware zoektocht opleveren. En dan blijkt maar weer hoe belangrijk het is om netjes te scripten!

Header already sent

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

echo 'Hello World!';
header('Refresh: 3; url=index.php');
?>

Warning: Cannot modify header information - headers already sent by (output started at C:\wamp\www\fouten.php:5) in C:\wamp\www\fouten.php on line 6

Dit is een veel voorkomende fout waar veel beginnende programmeurs moeite mee hebben. Hij wordt veroorzaakt doordat je voor de functies header(), session_start() en setcookie() nog helemaal geen output naar de browser verzonden mag hebben. Dat betekent geen echo, geen HTML maar ook geen loze spatie ergens buiten je php tags.

De foutmelding geeft ons ten eerste weer het script en regelnummer waar de fout is opgetreden. De melding geeft aan dat het een 'headers already sent' fout betreft. Verder geeft de foutmelding ook nog aan waar er al output naar de browser verzonden is. In ons geval in fouten.php op regel 5. En dat klopt, want daar staat onze echo.

De oplossing van deze fouten is niet altijd even eenvoudig. Waar je altijd op moet proberen te letten is dat je altijd eerst alle logica (php) afhandelt voordat je output (HTML) gaat genereren. In ons geval zullen we de header() dus voor de echo moeten plaatsen:

<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

header('Refresh: 3; url=index.php');
echo 'Hello World!';
?>

Ik krijg niets te zien?
Als je een lege pagina terug krijgt terwijl je toch echt output verwacht, zul je nog even goed naar je script moeten kijken. Controleer even of er wel degelijk output gegeven zou moeten worden.

In het andere geval zou het kunnen dat de display_errors instelling uit staat waardoor fouten helemaal niet weergegeven worden. Hoewel we dat telkens met die eerste twee regels code aanzetten, gebeurt dit pas op een moment nadat bijvoorbeeld parse errors opgetreden zijn. Deze worden dan alsnog niet weergegeven.

Dat kunnen we oplossen door een bestandje met de naam .htaccess (ja een punt als begin en verder geen extensie) in de root van onze website te zetten. In dit bestandje zetten we dan de volgende regel:

php_flag display_errors on

Nu staat de display_errors instelling ingeschakeld en worden ook de parse errors weergegeven.

Voor meer informatie over foutafhanding in PHP verwijs ik je graag door naar mijn tutorial over foutafhandeling in PHP. Daar ga ik veel dieper in op de verschillende mogelijkheden die je hebt met betrekking tot het afhandelen van fouten in PHP.

Nu zijn we dan echt aan het einde van deze tutorial gekomen. Ik hoop dat ik je hiermee de basis van PHP op een duidelijk manier heb kunnen uitleggen. Als je deze tutorial aandacht doorgenomen hebt, heb je genoeg kennis om te beginnen met het schrijven van eigen PHP scripts, het programmeren van je eigen toepassingen of wellicht het verder lezen van andere, moeilijkere tutorials.

Zoals je wellicht snel zult merken, is de kennis die je nu bezit echt nog maar de basis. De wijde wereld van het programmeren ligt nu voor je open. Andere onderwerpen die eigenlijk altijd hand in hand gaan met het gebruik van PHP zijn natuurlijk het gebruik van HTML en CSS, maar ook het gebruik van databases om je scripts nog dynamischer te maken, behoort nu tot de mogelijkheden.

Ik zal nog enkele links geven naar sites of tutorial die meer informatie geven over deze verschillende onderwerpen:

PHP
PHP.net Handleiding
Foutafhandeling in PHP
PHP Contactformulier met Swift Mailer
Filters in PHP 5

HTML
W3Schools HTML Tutorial
W3Schools XHTML Tutorial

CSS
W3Schools CSS Tutorial
Quirksmode artikelen over CSS
Websitemaken.be HTML en CSS Tutorials

Databases & SQL
SQL Beginners handleiding
W3Schools CSS Tutorial
PDO - Verbinden met verschillende databases
MySQL Handleiding
PostgreSQL Handleiding

Voor de opbouw van deze tutorial heb ik een voorbeeld genomen aan enkele andere tutorials voor beginnende programmeurs. Daarbij het ik onder andere gebruik gemaakt van:

[li]PHP Programmeren door Arjan Kapteijn[/li]
[li]Beginnen met PHP door Robert Deimain[/li]
[li]Een uitgebreide PHP Cursus door Mirax[/li]

Opmerkingen, vragen of suggesties over deze tutorial zijn natuurlijk altijd welkom! Deze tutorials is ook hier te vinden: PHP Beginners handleiding