PHP 8.3 nieuwe functies: typed constants en json_validate

PHP 8.3 verscheen op 23 november 2023 en in plaats van de taal opnieuw uit te vinden, brengt het tientallen praktische verbeteringen die het dagelijkse ontwikkelwerk soepeler maken. De hoogtepunten zijn typed class constants voor sterkere typeveiligheid, de functie json_validate() voor goedkope JSON-validatie, het #[\Override]-attribuut dat overervingsfouten vroeg opspoort, en een handvol stille prestatiewinsten. In dit artikel lopen we door de wijzigingen die je echt helpen, met echte, uitvoerbare code.

Typed class constants: constanten zijn eindelijk typeveilig

Jarenlang weigerde PHP typedeclaraties op constanten. Een subklasse kon een overgeërfde constante herdefiniëren met het verkeerde type, en de fout kwam pas tijdens runtime aan het licht — in het ergste geval in productie. Met PHP 8.3 kun je een type declareren op constanten van klassen, interfaces, traits en enums.

interface Gekleurd
{
    const string STANDAARD = 'blauw';
}

class Kaart implements Gekleurd
{
    // Fout: type komt niet overeen (string verwacht, int gegeven)
    // const string STANDAARD = 0xFF;
    const string STANDAARD = 'rood';
}

Het cruciale detail: de constante van het kind moet compatibel blijven met het type dat in de ouder is gedefinieerd. Is een constante getypeerd als int, dan kan een ervende klasse er geen string van maken. In grote codebases maakt dit contracten veel betrouwbaarder.

json_validate(): geldigheid controleren zonder geheugen te verspillen

Voorheen was de enige praktische manier om te weten of een string geldige JSON was, het aanroepen van json_decode() en controleren op fouten. Maar dat bouwde een complete PHP-datastructuur in het geheugen op, zelfs als je alleen een ja/nee-antwoord wilde. json_validate() lost precies die verspilling op: het parseert maar bouwt niets en zegt simpelweg of de invoer geldig is.

$ruw = '{"naam":"Aslain","talen":["tr","en","de"]}';

if (json_validate($ruw)) {
    $data = json_decode($ruw, true);
    // veilig verwerken
} else {
    // misvormde body — geef 400 terug
}

Dit is het waardevolst wanneer je webhook-bodies, API-verzoeken of grote door gebruikers aangeleverde payloads alleen wilt filteren op "is dit geldig?". Wanneer je de inhoud echt nodig hebt, roep je nog steeds json_decode() aan.

Het #[\Override]-attribuut: laat de engine je overrides verifiëren

Je denkt dat je een methode van de ouder overschrijft, maar er zit een kleine typefout in de naam; in plaats van overschrijven heb je een gloednieuwe methode gedefinieerd, en de bug verdwijnt stilletjes. Het #[\Override]-attribuut van PHP 8.3 elimineert deze hele klasse fouten: je verklaart dat een methode echt van een oudertype komt, en zo niet, dan werpt PHP een fatale fout op.

class BasisWachtrij
{
    public function verwerk(): void {}
}

class RedisWachtrij extends BasisWachtrij
{
    #[\Override]
    public function verwerk(): void
    {
        // gegarandeerd daadwerkelijk een override
    }
}

Het attribuut is onbetaalbaar in code die interfaces implementeert of diepe overervingsketens heeft. Op het moment dat een ouder een methode hernoemt, klaagt elke subklasse met #[\Override] meteen en voorkomt zo een stille regressie voordat die optreedt.

Dynamic class constant fetch en nieuwe string-helpers

Vóór PHP 8.3 betekende de naam van een constante in een variabele bewaren en er dynamisch toegang toe krijgen omwegen zoals constant(). Nu kun je er rechtstreeks bij met de accolade-syntaxis:

class Status
{
    const ACTIEF = 'actief';
    const INACTIEF = 'inactief';
}

$veld = 'ACTIEF';
echo Status::{$veld}; // "actief"

Er kwamen ook twee kleine maar handige functies voor het genereren van strings: str_increment() en str_decrement(). Ze verhogen en verlagen alfanumerieke strings op een logische manier, zoals een kentekenplaat of serienummer doorrolt:

echo str_increment('Az');  // "Ba"
echo str_increment('A9');  // "B0"
echo str_decrement('B0');  // "A9"

Readonly klonen en uitbreidingen van Randomizer

De readonly-eigenschappen die in PHP 8.2 werden geïntroduceerd waren krachtig, maar hadden één beperking: je kon hun waarde niet wijzigen tijdens het klonen. PHP 8.3 heft dat op — je kunt nu een readonly-eigenschap herinitialiseren binnen __clone(). Dit maakt het maken van "with"-achtige kopieën van onveranderlijke objecten veel schoner.

final class Geld
{
    public function __construct(
        public readonly int $centen,
    ) {}

    public function __clone(): void
    {
        // herassignatie toegestaan tijdens het klonen
    }
}

Aan de kant van willekeur kreeg de klasse Random\Randomizer nieuwe methoden: getFloat(), nextFloat() en getBytesFromString(). Ze bieden oplossingen van één regel en zonder vertekening om een willekeurige string uit een gegeven alfabet te genereren (wachtwoorden, tokens of couponcodes) of een float binnen een gecontroleerd bereik.

Prestaties en andere kleine details

PHP 8.3 claimt geen duizelingwekkende snelheidssprong, maar verbeteringen op engine- en JIT-niveau leveren stabiele, meetbare winst op bij typische webworkloads. Een paar andere opvallende punten:

• Bescherming tegen stack overflow: met zend.max_allowed_stack_size kan diepe of oneindige recursie stoppen met een nette fout in plaats van een segfault.
• Preciezere Date/Time-uitzonderingen: dateklassen werpen nu specifieke uitzonderingen zoals DateMalformedStringException in plaats van een generieke Exception.
• DateTime::createFromTimestamp(): een nieuwe statische methode om rechtstreeks en leesbaar een date-object op te bouwen uit een timestamp.
• Anonieme readonly-klassen: je kunt nu new readonly class { ... } schrijven.

Praktisch advies: begin je een nieuw project, kies dan meteen PHP 8.3 (of nieuwer). Verhoog bij een bestaand Laravel- of puur PHP-project eerst de versiebeperking in composer.json en draai daarna je testsuite; omdat 8.3 grotendeels achterwaarts compatibel is, verloopt de migratie meestal pijnloos.

Veelgestelde vragen

Is upgraden van PHP 8.2 naar 8.3 moeilijk?

In de meeste gevallen niet. PHP 8.3 introduceert weinig brekende wijzigingen; de belangrijkste nieuwe functies zijn aanvullend. Toch is het het veiligst om je geautomatiseerde tests te draaien en 8.3-ondersteuning van je afhankelijkheden te bevestigen voordat je naar productie gaat.

Is json_validate() altijd sneller dan json_decode()?

Het echte voordeel zit in geheugen: json_validate() bouwt geen PHP-datastructuur op en gebruikt dus minder geheugen bij grote payloads. Maar als je de data echt nodig hebt, roep je daarna alsnog json_decode() aan — in dat geval kan één keer decoderen en op fouten controleren zinvoller zijn dan twee aanroepen.

Breken typed constants bestaande constanten?

Nee. De typedeclaratie is optioneel; je huidige niet-getypeerde constanten blijven precies werken zoals voorheen. Je kunt types geleidelijk toevoegen, alleen daar waar je de extra garantie wilt.

Wil je je PHP-stack moderniseren? Laten we samen een Laravel- of puur PHP-upgrade naar 8.3 aanpakken, met typeveiligheid en een prestatiereview. Neem contact op en laten we je project bespreken.