PHP 8.x heeft de taal fundamenteel moderner gemaakt. Sinds de release van PHP 8.0 eind 2020 zijn er met versies 8.1, 8.2 en 8.3 features toegevoegd die de manier waarop je code schrijft radicaal veranderen. Denk aan enums, readonly properties, match expressions en een JIT-compiler. Als developer ontkom je er niet aan: moderne frameworks en packages vereisen steeds vaker PHP 8.x.
In dit artikel lopen we de belangrijkste PHP 8.x features door die je als developer moet kennen. Per feature krijg je een praktisch codevoorbeeld en uitleg over wanneer je het inzet.
Named arguments: duidelijkere functie-aanroepen
Named arguments (geïntroduceerd in PHP 8.0) laten je parameters bij naam doorgeven in plaats van op volgorde. Dat maakt functie-aanroepen leesbaarder en je kunt optionele argumenten overslaan.
// Voor PHP 8.0
htmlspecialchars($string, ENT_QUOTES | ENT_HTML5, 'UTF-8', false);
// Met named arguments
htmlspecialchars($string, double_encode: false);
Vooral bij functies met veel optionele parameters is dit een uitkomst. Je hoeft niet meer te onthouden wat de derde of vierde parameter ook alweer was.
Combineren met positional arguments
Je kunt named en positional arguments mixen, maar named arguments moeten altijd na de positional arguments komen.
array_fill(start_index: 0, count: 5, value: 'hallo');
Constructor property promotion: minder boilerplate
Een van de meest geliefde toevoegingen van PHP 8.0 is constructor property promotion. Je definieert properties direct in de constructor-signatuur.
// Oude manier
class User {
private string $name;
private string $email;
public function __construct(string $name, string $email) {
$this->name = $name;
$this->email = $email;
}
}
// Met property promotion
class User {
public function __construct(
private string $name,
private string $email,
) {}
}
Dit scheelt enorm veel boilerplate, vooral bij value objects. Als je domain-driven design in PHP toepast, worden je value objects veel compacter.
Match expressions: een betere switch
De match expression is een moderne vervanger voor switch. Hij is strikt (gebruikt === in plaats van ==), exhaustief en retourneert een waarde.
$status = match($code) {
200, 201, 204 => 'success',
301, 302 => 'redirect',
404 => 'not_found',
500, 502, 503 => 'server_error',
default => 'unknown',
};
Geen break statements meer vergeten. En als geen van de gevallen matcht zonder default, krijg je een UnhandledMatchError. Dat voorkomt sluipende bugs.
Enums: type-safe opsommingen
PHP 8.1 bracht eindelijk native enums. Voorheen gebruikte je constanten of klassen met statische methoden. Nu heb je echte, type-safe opsommingen.
enum OrderStatus: string {
case Pending = 'pending';
case Paid = 'paid';
case Shipped = 'shipped';
case Cancelled = 'cancelled';
public function label(): string {
return match($this) {
OrderStatus::Pending => 'In afwachting',
OrderStatus::Paid => 'Betaald',
OrderStatus::Shipped => 'Verzonden',
OrderStatus::Cancelled => 'Geannuleerd',
};
}
}
Je kunt enums gebruiken als type-hint, wat betekent dat je compiler/IDE ongeldige waarden direct signaleert. Dit past perfect in SOLID principes en domain modeling.
Backed enums vs pure enums
Een BackedEnum heeft een onderliggende waarde (string of int). Een pure enum niet. Backed enums zijn handig voor database-opslag, API's en serialisatie.
$status = OrderStatus::from('paid'); // Werpt exception bij onbekende waarde
$status = OrderStatus::tryFrom('onzin'); // Geeft null terug
Readonly properties: immutability zonder moeite
PHP 8.1 introduceerde readonly properties. Een readonly property kan alleen worden gezet vanuit de scope waarin hij is gedeclareerd, en daarna nooit meer gewijzigd.
class Money {
public function __construct(
public readonly int $amount,
public readonly string $currency,
) {}
}
$price = new Money(1995, 'EUR');
$price->amount = 0; // Error: Cannot modify readonly property
Dit is de nieuwe standaard voor value objects. Je hoeft geen private properties meer met alleen getters te maken.
In PHP 8.2 werd dit uitgebreid met readonly classes, waarbij alle properties automatisch readonly zijn.
readonly class Point {
public function __construct(
public float $x,
public float $y,
) {}
}
First-class callable syntax
PHP 8.1 voegde een kortere manier toe om callables te maken. In plaats van strings of closures kun je nu de (...) syntax gebruiken.
// Oude manier
$fn = Closure::fromCallable([$this, 'formatUser']);
$fn = 'strtoupper';
// First-class callable syntax
$fn = $this->formatUser(...);
$fn = strtoupper(...);
$names = array_map(strtoupper(...), $users);
Dit werkt goed samen met functionele patterns. Zie ook onze uitleg over functies en scope in PHP voor de basis van callables.
Union en intersection types
PHP 8.0 bracht union types (string|int), PHP 8.1 intersection types (Countable&Iterator), en PHP 8.2 voegde Disjunctive Normal Form (DNF) types toe waarmee je beide kunt combineren.
// Union type
function format(string|int $value): string { /* ... */ }
// Intersection type
function process(Countable&Iterator $collection): void { /* ... */ }
// DNF (PHP 8.2+)
function handle((Countable&Iterator)|null $input): void { /* ... */ }
Met deze types kun je veel preciezer aangeven wat een functie accepteert zonder je tot interfaces of abstracte klassen te hoeven beperken.
De JIT-compiler
De Just-In-Time compiler is een van de grootste technische vernieuwingen in PHP 8.0. Hij compileert hot code paths tijdens runtime naar machinecode. De officiële PHP RFC bevat alle details over hoe het werkt.
Voor typische I/O-gebonden webapps (veel database- en API-calls) is de winst beperkt. Voor CPU-intensieve workloads, beeldbewerking, wiskundige berekeningen, machine learning, is de impact aanzienlijk.
; php.ini
opcache.jit_buffer_size=100M
opcache.jit=tracing
Voor meer over performance-tuning, zie onze gids over PHP performance optimalisatie.
Nieuwe functies en kleine pareltjes
Naast de grote features zijn er tientallen handige toevoegingen:
str_contains(),str_starts_with(),str_ends_with(), eindelijk in de core (PHP 8.0)array_is_list(), check of een array een sequentiële lijst is (PHP 8.1)- Nullsafe operator
?->, kortsluiting bij null (PHP 8.0) json_validate(), valideer JSON zonder te parsen (PHP 8.3)- Typed class constants (PHP 8.3)
#[Override]attribuut (PHP 8.3), expliciet aangeven dat je een parent-methode overschrijft
Nullsafe operator in actie
// Oude manier
$country = null;
if ($user !== null && $user->getAddress() !== null) {
$country = $user->getAddress()->getCountry();
}
// Met nullsafe
$country = $user?->getAddress()?->getCountry();
Attributes: metadata zonder docblocks
PHP 8.0 bracht native attributes (vergelijkbaar met annotaties in Java of decorators in Python). Frameworks zoals Symfony en Laravel gebruiken ze intensief voor routing, validatie en ORM-mapping.
use Symfony\Component\Routing\Annotation\Route;
class ProductController {
#[Route('/products/{id}', methods: ['GET'])]
public function show(int $id): Response {
// ...
}
}
Dit is veel krachtiger dan de oude @Route-docblocks, omdat attributes echt onderdeel zijn van de taal en via reflectie uitleesbaar zijn. Zie ook onze uitleg over middleware en routing in PHP.
Deprecaties en breaking changes
Niet alle wijzigingen zijn fijn. Een paar dingen om op te letten bij het upgraden:
- Dynamische properties zijn deprecated in PHP 8.2 (gebruik
#[AllowDynamicProperties]of definieer properties expliciet) utf8_encode()enutf8_decode()zijn verwijderd in PHP 8.2${...}string interpolatie is deprecated (gebruik{$...})- Striktere type coercion:
nulldoorgeven aan ingebouwde functies met non-nullable parameters geeft nu een deprecation warning
De PHP migratiedocumentatie beschrijft alle breaking changes per versie.
Welke versie moet je gebruiken?
Kies altijd de nieuwste stabiele versie die je frameworks ondersteunen. Op het moment van schrijven is PHP 8.3 de actieve release en PHP 8.4 komt eraan. PHP 8.1 krijgt nog security-only support tot eind 2025.
Voor een overzicht van supported versies zie je de officiële PHP supported versions pagina.
Als je een bestaande codebase upgradet, zorg dat je testing in PHP goed op orde hebt. Een volledige testsuite is de enige manier om zeker te weten dat een upgrade niets breekt.
Veelgestelde vragen
Wat zijn de belangrijkste PHP 8.x features?
De belangrijkste PHP 8.x features zijn named arguments, enums, readonly properties, match expressions, constructor property promotion, de JIT-compiler en first-class callable syntax. Deze features maken je code korter, veiliger en sneller.
Moet ik upgraden naar PHP 8.x?
Ja, een upgrade naar PHP 8.x is sterk aan te raden. Je krijgt betere performance dankzij de JIT-compiler, strengere typechecking en moderne syntax. Oudere PHP-versies zoals 7.4 krijgen geen security updates meer.
Wat is het verschil tussen PHP 8.0, 8.1, 8.2 en 8.3?
PHP 8.0 introduceerde de JIT en named arguments. PHP 8.1 bracht enums en readonly properties. PHP 8.2 voegde readonly classes en disjunctive normal form types toe. PHP 8.3 bracht typed class constants en de json_validate functie.
Zijn PHP 8.x features backwards compatible?
De meeste nieuwe features zijn additief en breken geen bestaande code. Er zijn echter breaking changes zoals striktere type checks en deprecated functies. Test je applicatie grondig voordat je upgradet naar een nieuwe major versie.
Wat is de JIT-compiler in PHP 8?
De Just-In-Time compiler compileert veelgebruikte PHP-code tijdens runtime naar machinecode. Dit levert vooral winst op bij CPU-intensieve taken. Voor typische web-applicaties is de impact kleiner, maar wel merkbaar.
Conclusie
PHP 8.x heeft de taal volwassen gemaakt. Met enums, readonly properties, match expressions en strengere types kun je code schrijven die veiliger en leesbaarder is dan ooit. Combineer deze features met moderne design patterns in PHP en je tilt de kwaliteit van je codebase naar een hoger niveau.
Begin klein: pas named arguments en constructor property promotion toe in nieuwe code. Vervang strings door enums waar dat logisch is. Maak je value objects readonly. Voor je het weet schrijf je moderne, type-safe PHP waar je trots op kunt zijn.