PHP
Design mönster

Introduktion

Metodkedja i PHP

Method Chaining är en teknik som förklaras i Martin Fowlers bok Domänspecifika språk . Metodkedjning sammanfattas som

Gör modifieringsmetoder returnerar värdobjektet så att flera modifierare kan åberopas i ett enda uttryck .

Överväg den här icke-kedjade / vanliga kodkoden (portad till PHP från ovannämnda bok)

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

Metodkedjning låter dig skriva ovanstående uttalanden på ett mer kompakt sätt:

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

Allt du behöver göra för att detta ska fungera är att return $this i de metoder du vill kedja från:

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
    }
}

När du ska använda den

Det primära användningsfallet för att använda metodkedjning är när man bygger interna domänspecifika språk. Method Chaining är en byggsten i Expression Builders och flytande gränssnitt . Det är dock inte synonymt med dem . Metodkedjning möjliggör bara dessa. Citera Fowler:

Jag har också märkt en vanlig missuppfattning - många verkar likställa flytande gränssnitt med Method Chaining. Visst kedja är en vanlig teknik att använda med flytande gränssnitt, men verklig flyt är mycket mer än så.

Med det sagt är att använda Method Chaining bara för att undvika att skriva värdobjektet betraktas som en kodlukt av många. Det skapar uppenbara API: er, särskilt när du blandar med icke-kedjade API: er.

Ytterligare anmärkningar

Kommandosökningsseparation

Command Query Separation är en designprincip framställd av Bertrand Meyer . Den anger att metoder som muterar tillstånd ( kommandon ) inte ska returnera någonting, medan metoder som returnerar något ( frågor ) inte bör mutera tillstånd. Detta gör det lättare att resonera om systemet. Metodkedjning bryter mot denna princip eftersom vi muterar tillstånd och returnerar något.

Getter

När du använder klasser som implementerar metodkedjning bör du vara särskilt uppmärksam när du kallar getter-metoder (det vill säga metoder som returnerar något annat än $this ). Eftersom getters måste returnera ett annat värde än $this , kedja ytterligare en metod på en getter gör samtalet verka på den blivit värde, inte på det ursprungliga objektet. Även om det finns vissa användningsfall för kedjor med kedjor, kan de göra koden mindre läsbar.

Demeterlag och påverkan på tester

Metodkedja som presenteras ovan bryter inte med Demeter Law . Det påverkar inte heller testning. Det beror på att vi returnerar värdinstansen och inte någon samarbetspartner. Det är en vanlig missuppfattning som härrör från människor som förvirrar bara metodkedjning med flytande gränssnitt och expressionsbyggare . Det är först när Method Chaining returnerar andra objekt än värdobjektet som du bryter mot lagen om demeter och slutar med håna fests i dina tester.