Hoe definieer je functies met types en standaardwaarden?

Question

Accepted Answer

PHP-functies worden gedefinieerd met het `function`-trefwoord. Moderns PHP ondersteunt **type-aankondigingen** op parameters en retourwaarden, **standaardwaarden** en variadische parameters — wat functies robuuster en zelfverklarend maakt.

## Basis functies met type-aankondigingen

```php
<?php
// modern PHP — typed parameters and a typed return
function add(int $a, int $b): int {
    return $a + $b;
}

function greet(string $name, string $greeting = "Hello"): string {  // default value
    return "$greeting, $name";
}

greet("Ann");              // "Hello, Ann"
greet("Ann", "Hi");        // "Hi, Ann"
```

Type-aankondigingen (`int $a`, `: int` retourtype) laten PHP argument- en retourtypen controleren — bugs worden opgespoord en de bedoeling wordt gedocumenteerd. Standaardwaarden maken parameters optioneel.

## Nullable types en union types (PHP 8+)

```php
function find(?int $id): ?User {        // ? = nullable (int|null, User|null)
    return $id ? lookup($id) : null;
}

function process(int|string $input): void {   // union type — int OR string (PHP 8)
    // ...
}
```

`?Type` staat null toe; **union types** (`int|string`, PHP 8) staan meerdere typen toe — wat handtekeningen nauwkeurig maakt.

## Variadische en benoemde argumenten

```php
function sum(int ...$numbers): int {     // variadic — any number of int args
    return array_sum($numbers);
}
sum(1, 2, 3);            // 6

// named arguments (PHP 8) — pass by parameter name, skip optional ones
greet(name: "Ann", greeting: "Hey");
```

## Waarom het belangrijk is

```php
<?php
declare(strict_types=1);    // at the top of the file — enforce STRICT type checking

add("5", 3);   // ❌ TypeError with strict_types (without it, "5" would coerce to 5)
```

`declare(strict_types=1)` maakt type-aankondigingen streng — PHP weigert niet-overeenkomende typen in plaats van deze stilzwijgend te coörcineren, wat de aanbevolen moderne praktijk is om bugs op te vangen.

## Waarom het belangrijk is

Het begrijpen van moderne PHP-functiedefinities — vooral **type-aankondigingen** — is belangrijk voor het schrijven van robuuste, onderhoudbare code en weerspiegelt hoe ver PHP is geëvolueerd vanuit zijn los-getyped oorsprong.

Getyped parameters en retourwaarden (plus nullable en union types) maken functies zelfverklarend en laten PHP typefouten opvangen, terwijl standaard- en benoemde argumenten en variadics flexibele, leesbare handtekeningen bieden.

De belangrijkste moderne praktijk is **`declare(strict_types=1)`**, die strenge typecontrole afdwingt (niet-overeenkomsten afwijzen in plaats van deze stilzwijgend te coörcineren) — een belangrijk hulpmiddel om bugs vroegtijdig op te vangen en betrouwbare code te schrijven.

Weten hoe je goed getypeerde functies met standaardinstellingen definieert en strikte typen gebruikt, is alledaagse kennis voor professionele moderne PHP-ontwikkeling, onderscheidend solide, type-veilige code van de los-getyped stijl van ouder PHP.