PHP-lessen - les 7 - PHP-functies en functioneel programmeren

Ik denk dat we nu het punt hebben bereikt waarop het tijd is… om echt te beginnen met programmeren. Na deze les kun je gerust zeggen dat je hebt geprogrammeerd in PHP. Heel vaak moet je code schrijven die op meerdere pagina’s of in verschillende .php-bestanden wordt hergebruikt. Om te voorkomen dat we dezelfde code telkens kopiëren, bestaan er in PHP functies.

Een functie is een zelfstandige code-eenheid die een bepaalde berekening uitvoert. We hebben al enkele voorbeelden van functies gezien in eerdere lessen:

• time() – geeft het aantal seconden sinds het begin van de Unix-epoche terug;
• print() en echo() – tonen HTML-uitvoer op het scherm;
• floor() – retourneert het gehele deel van een decimaal getal.

Je hebt waarschijnlijk al gemerkt dat functies altijd worden opgeroepen met haakjes (). De algemene schrijfwijze is dus: functie_naam(). De naamgevingsregels zijn hetzelfde als voor variabelen, met als verschil dat functies geen dollarteken ($) gebruiken.

Waaruit bestaat een functie?

<?php
function plus_one($x){  // definitie van de functie
  $x = $x + 1;          // functielichaam
  return $x;            // teruggegeven waarde
}

$y = 1;
$y = plus_one($y);      // functieaanroep
print $y;
?>

De naam van de functie zegt het al: ze telt één op bij de variabele. Laten we de onderdelen nader bekijken.

Functienaam

De regels voor functienamen zijn gelijk aan die voor variabelen:

1. De functienaam moet beginnen met een letter of een underscore _.
2. Ze mag alleen letters, cijfers en underscores bevatten (A–Z, a–z, 0–9, _).
3. Er mogen geen spaties in staan. Bij samengestelde namen gebruik je een underscore (my_function()) of camelCase (myFunction()).

Een nieuwe functie definieer je met het sleutelwoord function, gevolgd door de naam van de functie.

Functielichaam

Het functielichaam bevat de code die wordt uitgevoerd. In ons voorbeeld is dat:

function plus_one($x){
  $x = $x + 1;
  return $x;
}

Het functielichaam wordt altijd tussen accolades {} gezet.

Returnwaarde

Het gedeelte na het sleutelwoord return bepaalt de waarde die de functie teruggeeft. Dit is het resultaat van de berekening. In ons voorbeeld retourneert de functie de waarde van $x.

Functieparameters

Parameters zijn waarden die tussen de haakjes van de functienaam staan. In ons voorbeeld wordt één parameter ($x) doorgegeven, maar je kunt er ook meerdere gebruiken, gescheiden door komma’s:

<?php
function myFunction($x1, $x2, $x3){

}

$y = myFunction($z, 34, 'Hallo, wereld!');
?>

De parameters in de functiedefinitie geven aan hoeveel argumenten nodig zijn. Als je er te weinig of te veel opgeeft bij het aanroepen, krijg je een foutmelding:

<?php
function myFunction($x1, $x2, $x3){

}

$y = myFunction(34, 'Hallo, wereld!'); // fout: te weinig argumenten!
?>

De namen van de parameters binnen de functie zijn lokaal en hoeven niet overeen te komen met de namen van de variabelen die je doorgeeft.

Voorbeeld: een wiskundige functie

Laten we een functie maken voor de berekening y = -2x + 4 en de waarden van y vinden voor verschillende x:

<?php
function myFunction($x){
  $y = -2 * $x + 4;
  return $y;
}

$z1 = myFunction(1);
$z2 = myFunction(2);
$z3 = myFunction(3);
print $z1 . '<br />' . $z2 . '<br />' . $z3;
?>

Het resultaat zal zijn: -2, 0 en 2. Nu zie je duidelijk hoe functies in PHP werken.

Functioneel programmeren

Misschien heb je al geraden waarom dit “functioneel programmeren” wordt genoemd — omdat functies de kern vormen van de code. Een typisch PHP-bestand kan tientallen functies bevatten. Hoe houd je dat overzichtelijk? Simpel: door functies te groeperen en op te slaan in aparte bestanden.

<?php
function incr($x){
  $x++;
  return $x;
}

function decr($y){
  $y--;
  return $y;
}

$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;
?>

Hier verhogen we vier keer met 1 en verlagen we één keer met 1 — het resultaat is dus 3. De positie van de functies in het bestand maakt niet uit:

<?php
$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;

function incr($x){
  $x++;
  return $x;
}

function decr($y){
  $y--;
  return $y;
}
?>

Het resultaat blijft hetzelfde, want PHP herkent functies, ongeacht waar ze staan in de code. Maar als je tientallen of honderden functies hebt, is het verstandig ze per onderwerp in aparte bestanden te bewaren.

Functies opslaan in aparte bestanden

decr.php:

<?php
function decr($y){
  $y--;
  return $y;
}
?>

incr.php:

<?php
function incr($x){
  $x++;
  return $x;
}
?>

Verwijder nu de functiedefinities uit index.php, want dubbele definities veroorzaken fouten. Ook het oproepen van een niet-bestaande functie geeft een foutmelding, dus wees voorzichtig.

Voeg vervolgens de bestanden met functies toe met behulp van include:

<?php
include 'incr.php';
include 'decr.php';

$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;
?>

Nu kun je de functies uit incr.php en decr.php gebruiken zonder je hoofdscript te overladen. Het resultaat blijft hetzelfde — 3.

Dit is nog maar het begin van functioneel programmeren in PHP. In de volgende lessen gaan we hier dieper op in.