PHP Beginnershandleiding

  1. Inleiding
  2. Mijn eerste PHP script
  3. Variabelen
  4. Statements
  5. Loops
  6. Arrays
  7. Functies
  8. Formulieren
  9. Superglobals
  10. Sessies nader bekeken: een eerste loginscript
  11. Netjes scripten
  12. Debuggen: het oplossen van PHP fouten
  13. Slotwoord en referenties
  14. Reacties op deze tutorial

Functies

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:
Code
1
2
3
4
5
6
<?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:
Code
1
2
3
4
5
6
7
8
9
10
<?php
// Functie definiëren
function geefWeer()
{
    echo 
'Hello World!';
}

// Functie aanroepen
geefWeer();
?>
Output
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:
Code
1
2
3
4
5
6
7
8
9
10
<?php
// Functie definiëren
function geefTerug()
{
    return 
'Hello World!';
}

// Functie aanroepen
echo geefTerug();
?>
Output
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:
Code
1
2
3
<?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:
Code
1
2
3
4
5
6
7
8
9
10
11
12
<?php
// Functie definiëren
function geefWeer($sString)
{
    echo 
$sString.'<br />';
}

// Functie aanroepen
$sTekst 'Hello World!';
geefWeer($sTekst);
geefWeer('Een tweede tekst');
?>
Output
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.
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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(1234);
echo 
'$aTestArray bevat '.tel($aTestArray).' items.';
?>
Output
$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:
Code
1
2
3
4
5
6
7
8
9
10
<?php
if(strlen($sGebruikersnaam) > && substr($sGebruikersnaam01) != '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:
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
// Functie definiëren
function checkGebruikersnaam($sGebruikersnaam)
{
    if(
strlen($sGebruikersnaam) > && substr($sGebruikersnaam01) != 'A')
    {
        return 
true;
    }
    else
    {
        return 
false;
    }
}

// Functie aanroepen
$sGebruiker 'Joren';
if(
checkGebruikersnaam($sGebruiker))
{
    echo 
'Deze gebruikersnaam is geldig!';
}
else
{
    echo 
'Ongeldige gebruikersnaam';
}
?>
Output
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.
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?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($fTotaal2);
}

// Functie aanroepen
$aBedragen = array(5.459.9534.95);
echo 
'Totaal excl. BTW: '.calcTotaal($aBedragen).'<br />';
echo 
'Totaal incl. BTW: '.calcTotaal($aBedragentrue).'<br />';
?>
Output
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:
Code
1
2
3
<?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.

Vorige Volgende