PHP
Ontwerp patronen

Invoering

Methode Chaining in PHP

Method Chaining is een techniek die wordt uitgelegd in het boek Domain Specific Languages van Martin Fowler . Methode Chaining is samengevat als

Zorgt dat modificatiemethoden het hostobject retourneren, zodat meerdere modificaties in een enkele expressie kunnen worden aangeroepen .

Overweeg dit niet-ketenende / reguliere stuk code (overgezet naar PHP uit het bovengenoemde boek)

$hardDrive = new HardDrive;
$hardDrive->setCapacity(150);
$hardDrive->external();
$hardDrive->setSpeed(7200);

Met Method Chaining kunt u de bovenstaande verklaringen op een compactere manier schrijven:

$hardDrive = (new HardDrive)
    ->setCapacity(150)
    ->external()
    ->setSpeed(7200);

Het enige dat u hoeft te doen om dit te laten werken, is return $this te return $this volgens de methoden die u wilt koppelen:

class HardDrive {
    protected $isExternal = false;
    protected $capacity = 0;
    protected $speed = 0;

    public function external($isExternal = true) {
        $this->isExternal = $isExternal;        
        return $this; // returns the current class instance to allow method chaining
    }

    public function setCapacity($capacity) {
        $this->capacity = $capacity;        
        return $this; // returns the current class instance to allow method chaining
    }

    public function setSpeed($speed) {
        $this->speed = $speed;        
        return $this; // returns the current class instance to allow method chaining
    }
}

Wanneer gebruiken

De belangrijkste use cases voor het gebruik van Method Chaining zijn bij het bouwen van interne domeinspecifieke talen. Methode Chaining is een bouwsteen in expressiebouwers en vloeiende interfaces . Het is echter niet synoniem met die . Method Chaining maakt dat alleen mogelijk. Fowler citeren:

Ik heb ook een veel voorkomende misvatting opgemerkt - veel mensen lijken vloeiende interfaces te vergelijken met Method Chaining. Kettingen is zeker een veelgebruikte techniek om te gebruiken met vloeiende interfaces, maar echte vloeiendheid is veel meer dan dat.

Dat gezegd hebbende, wordt het gebruik van Method Chaining alleen om het schrijven van het hostobject te vermijden door velen beschouwd als een codegeur . Het zorgt voor niet voor de hand liggende API's, vooral bij het mixen met API's zonder keten.

extra notities

Command Query Separation

Command Query Separation is een ontwerpprincipe naar voren gebracht door Bertrand Meyer . Het stelt dat methoden die de status ( opdrachten ) muteren niets moeten retourneren, terwijl methoden die iets retourneren ( query's ) de status niet moeten muteren. Dit maakt het eenvoudiger om over het systeem te redeneren. Methode Chaining schendt dit principe omdat we de staat veranderen en iets retourneren.

getters

Let bij het gebruik van klassen die method chaining implementeren, vooral op bij het oproepen van getter-methoden (dat wil zeggen methoden die iets anders retourneren dan $this ). Omdat getters een andere waarde dan $this moeten retourneren, zorgt het koppelen van een extra methode aan een getter ervoor dat de aanroep werkt op de verkregen waarde, niet op het oorspronkelijke object. Hoewel er enkele use cases zijn voor geketende getters, kunnen ze code minder leesbaar maken.

Wet van Demeter en impact op testen

Methode Chaining zoals hierboven gepresenteerd is niet in strijd met de wet van Demeter . Het heeft ook geen invloed op testen. Dat komt omdat we de hostinstantie retourneren en niet een of andere medewerker. Het is een veel voorkomende misvatting afkomstig van mensen die alleen Method Chaining verwarren met vloeiende interfaces en expressiebuilders . Alleen wanneer Method Chaining andere objecten retourneert dan het hostobject, overtreed je de Wet van Demeter en eindig je met Mock-fests in je tests.