Scriptorama.nl

In mijn overzicht van de verschillende nieuwe features in PHP 5.3 zijn we al langs namespaces, verbeterde DateTime functionaliteit en de nieuwe lambda en closure functies geweest. Vandaag bekijken we een van de laatste grote toevoegingen aan de taal PHP in PHP 5.3: Late Static Binding.

Wat is Late Static Binding?

Late Static Binding is een oplossing voor een 'probleem' dat sinds PHP 5 bestaat. Op het moment dat je statische methoden gebruikt was PHP niet helemaal bewust van eventuele inheritance die van toepassing is. Daardoor is het lastig te bepalen waar een aanroep nu precies vandaan komt en dat beperkte de nuttigheid van statische methodes.

In PHP 5.2 zou je bijvoorbeeld de volgende code kunnen hebben:

Hier is het antwoord A en niet B zoals misschien wel gewenst was. Late Static Binding brengt hier verandering in. Door wijzigingen in manier waarop gegevens worden doorgegeven is het mogelijk te bepalen welke class een methode heeft aangeroepen. Hiervoor gebruiken we de nieuwe functie get_called_class():

Late Static Binding forward de aanroep informatie, die vervolgens door het static:: keyword en de get_called_class() functie gebruikt kunnen worden. Er zijn 3 situaties waarin forwarding plaats vindt:

1. Forwarding vindt automatisch plaats als een aangeroepen methode niet gedefinieerd staat in de Child klasse, maar wel in de Parent klasse.

2. Forwarding vindt plaats op het moment dat je een keyword gebruikt om naar een parent te refereren. Het gaat hier om de keywords parent en self.

3. Tenslotte vindt forwarding plaats als je de functies forward_static_call() of forward_static_call_array() gebruikt. Deze sturen de aanroep informatie expliciet door. Met forward_static_call_array() kun je ook nog een array met argumenten doorgeven.

Forwarding vindt niet plaats op het moment dat je een parent expliciet, daarmee bedoel ik aan de hand van z'n klassenaam, aanroept vanuit een Child. Een code voorbeeld van elke situatie:

Het gebruik van het static keyword

Dat is niet het hele verhaal, want je kunt vanuit een parent klasse ook weer 'terug' naar een child klasse en dat kan middels het static keyword dat ik net al aanhaalde. Het keyword static, dat we al gebruiken in de definitie van static variabelen en static methodes, zal als er forwarding informatie beschikbaar is, ook een referentie zijn naar de klasse die de aanroep heeft gedaan:

Je ziet hier in A::bouw() twee manieren waarop we met het static keyword terug refereren naar de aanroepende klasse. Ten eerste gebruiken we static::$naam om een statische variabele uit te lezen uit de aanroepende klasse en daarna gebruiken we new static() om een nieuwe instantie aan te maken van de aanroepende klasse.

Kortom, hoewel A geen idee heeft welke exacte klasse hem nou heeft aangeroepen, middels het static keyword is hij toch in staat er iets mee te doen.

Hét LSB voorbeeld: ActiveRecord

Allemaal leuk en aardig maar met simpele klassenamen als B en C wordt het nut nog niet echt duidelijk. Een grote motivatie voor het implementeren van late static binding en daarom tevens hét voorbeeld van Late Static Binding lijkt het ActiveRecord design pattern te zijn.

Het ActiveRecord is een design pattern waarbij 1 object gelijk staat aan 1 rij uit een tabel. Daarbij biedt het object alle functionaliteiten aan om het record verder te bewerken en verwerken. Met Late Static Binding, ben je in staat om alle benodigde functionaliteit te definieëren in de ActiveRecord class, terwijl je voor elke tabel enkel een klasse hoeft te maken die ervan extend:

De belangrijkste methode uit het voorbeeld is natuurlijk ActiveRecord::getById(). Deze static methode gebruikt de verschillende features die late static binding biedt om een generieke getById() functionaliteit te bieden, dus zonder expliciete kennis van de tabelnamen te hebben.

Ten eerste gebruik ik get_called_class() om te bepalen welke klasse de aanroep deed. Het resultaat daarvan gebruik ik vervolgens in de SQL query waar ik ook nog een 's' achter de tabel naam plaats. Een kleine conventie: een User vinden we in de tabel Users. Als we dan de gegevens uit de Database hebben gebruik ik het static keyword om een nieuwe instantie te maken van de aanroepende klasse met de data uit de database.

De klasse ActiveRecord is standalone niet nuttig, dus we zullen per tabel een klasse moeten maken, die volgens onze conventie de tabelnaam definieert. Die zie je hierboven als de User klasse. Het enige wat we hoeven te doen voor deze klasse is overerven van ActiveRecord, de columns te definieëren zodat de magic methods hun werk kunnen doen, en dan hebben we alle functionaliteit binnen handbereik:

Conclusie

Late Static Binding voegt wat missende functionaliteit toe wanneer je gebruik maakt van static aanroepen. Hoewel het misschien even lastig is om helemaal te begrijpen waarom dit nou nuttig is, iets waar ik zeker last van had, komt dat vanzelf als je er even mee speelt. Vooral het automatische forwarding via parent voelt alsof het er altijd al in had moeten zitten :).