Strikt typen in PHP verwijst naar het expliciet specificeren en afdwingen van typen van variabelen en functies om meer voorspelbaar en minder foutgevoelig gedrag van de code te verzekeren. Inzicht in strikt typen kan helpen om bugs te voorkomen die ontstaan door onbedoelde type conversies of foutieve aannames over het type van variabelen en return waarden van functies.
PHP is oorspronkelijk ontworpen als een losjes getypeerde taal, wat betekent dat het automatisch typeconversies uitvoert wanneer dat nodig is. Bijvoorbeeld, een string die een numeriek waarde bevat kan automatisch worden geconverteerd naar een integer of float in een wiskundige operatie. Dit gemak kan echter ook leiden tot lastige bugs en onvoorspelbaar gedrag van de applicatie.
Zodra strikt typen is ingeschakeld in PHP, worden deze automatische typeconversies uitgesloten. In plaats daarvan moet je expliciet specificeren welk type een variabele of returnwaarde moet hebben, en PHP zal dit strict handhaven. Dit wordt gedaan door een zogenaamde “declare(strict\_types=1);” uitspraak aan het begin van het PHP-script toe te voegen.
Hier is een voorbeeld van hoe strikt typen in werking treedt:
```
declare(strict_types=1);
function addNumbers(int $a, int $b): int {
return $a + $b;
}
echo addNumbers(5, 10); // Werkt correct en retourneert 15
echo addNumbers(‘5’, 10); // Fout: een string als parameter doorgeven veroorzaakt een TypeError
?>
```
1. Betere Code Kwaliteit en Onderhoudbaarheid: Het expliciet specificeren van typen maakt het gemakkelijker om de code te begrijpen en te onderhouden. Andere ontwikkelaars kunnen snel zien welk type data verwacht wordt.
1. Vermindert Bugs en Onvoorziene Gedrag: Strikte types helpen om bugs te identificeren en te vermijden door type mismatches te vangen tijdens de ontwikkelingsfase in plaats van op runtime.
1. Optimalisatie: Sommige type declaraties kunnen PHP helpen om code beter te optimaliseren, aangezien de engine minder type checks hoeft uit te voeren.
1. Meer Boilerplate Code: Ontwikkelaars moeten expliciet typen declareren wat de code uitgebreider maakt en in sommige gevallen minder flexibel.
1. Compatibiliteits Problemen: Bestaande code die afhankelijk is van PHP’s automatische typeconversies moet aangepast worden, wat tijdrovend kan zijn.
Naast functies, kunnen strict types ook worden toegepast op methoden in klassen. Hier zijn een paar voorbeelden:
```
declare(strict_types=1);
class Calculator { public function add(int $a, int $b): int { return $a + $b; }
public function divide(float $a, float $b): float { if ($b === 0.0) { throw new \InvalidArgumentException(‘Division by zero’); } return $a / $b; } }$calc = new Calculator();
echo $calc->add(10, 5); // Werkt correct
echo $calc->divide(10.0, 2.0); // Werkt correct
echo $calc->divide(10, ‘2’); // Fout door type mismatch
?>
```
1. PHP Internals en Handleiding:
- https://www.php.net/manual/en/language.types.declarations.php
- https://www.php.net/manual/en/functions.arguments.php#functions.arguments.type-declaration
1. Officiële PHP RFC (Request for Comments):
- https://wiki.php.net/rfc/scalar_type_hints\_v5
Door strikt typen te gebruiken, kun je robuustere en voorspelbaardere PHP-applicaties ontwikkelen, hoewel het enige aanpassing en extra inspanning kan vergen bij het schrijven en onderhouden van de code.
