PHP-Methodenverkettung oder fließende Schnittstelle?

Question 1

Ich verwende PHP 5 und habe von einer neuen Funktion im objektorientierten Ansatz gehört, die als „Methodenverkettung“ bezeichnet wird. Was ist es genau? Wie setze ich es um?

Question 2

Es ist wirklich ziemlich einfach. Sie haben eine Reihe von Mutator-Methoden die alle das ursprüngliche (oder andere) Objekt zurückgeben. Auf diese Weise können Sie weiterhin Methoden für das zurückgegebene Objekt aufrufen.

<?php
class fakeString
{
    private $str;
    function __construct()
    {
        $this->str = "";
    }
    
    function addA()
    {
        $this->str .= "a";
        return $this;
    }
    
    function addB()
    {
        $this->str .= "b";
        return $this;
    }
    
    function getStr()
    {
        return $this->str;
    }
}


$a = new fakeString();


echo $a->addA()->addB()->getStr();

Dies gibt “ab” aus

Probieren Sie es online aus!

Question 3

Grundsätzlich nehmen Sie ein Objekt:

$obj = new ObjectWithChainableMethods();

Rufen Sie eine Methode auf, die a effektiv ausführt return $this; Am Ende:

$obj->doSomething();

Da es dasselbe Objekt zurückgibt, oder besser gesagt a Hinweis für dasselbe Objekt können Sie weiterhin Methoden derselben Klasse vom Rückgabewert aufrufen, wie folgt:

$obj->doSomething()->doSomethingElse();

Das ist es wirklich. Zwei wichtige Dinge:

Wie Sie bemerken, ist es nur PHP 5. Es wird in PHP 4 nicht richtig funktionieren, weil es Objekte nach Wert zurückgibt und das bedeutet, dass Sie Methoden für verschiedene Kopien eines Objekts aufrufen, was Ihren Code beschädigen würde.

Auch hier müssen Sie das Objekt in Ihren verkettbaren Methoden zurückgeben:

public function doSomething() {
    // Do stuff
    return $this;
}

public function doSomethingElse() {
    // Do more stuff
    return $this;
}

Question 4

Versuchen Sie diesen Code:

<?php
class DBManager
{
    private $selectables = array();
    private $table;
    private $whereClause;
    private $limit;

    public function select() {
        $this->selectables = func_get_args();
        return $this;
    }

    public function from($table) {
        $this->table = $table;
        return $this;
    }

    public function where($where) {
        $this->whereClause = $where;
        return $this;
    }

    public function limit($limit) {
        $this->limit = $limit;
        return $this;
    }

    public function result() {
        $query[] = "SELECT";
        // if the selectables array is empty, select all
        if (empty($this->selectables)) {
            $query[] = "*";  
        }
        // else select according to selectables
        else {
            $query[] = join(', ', $this->selectables);
        }

        $query[] = "FROM";
        $query[] = $this->table;

        if (!empty($this->whereClause)) {
            $query[] = "WHERE";
            $query[] = $this->whereClause;
        }

        if (!empty($this->limit)) {
            $query[] = "LIMIT";
            $query[] = $this->limit;
        }

        return join(' ', $query);
    }
}

// Now to use the class and see how METHOD CHAINING works
// let us instantiate the class DBManager
$testOne = new DBManager();
$testOne->select()->from('users');
echo $testOne->result();
// OR
echo $testOne->select()->from('users')->result();
// both displays: 'SELECT * FROM users'

$testTwo = new DBManager();
$testTwo->select()->from('posts')->where('id > 200')->limit(10);
echo $testTwo->result();
// this displays: 'SELECT * FROM posts WHERE id > 200 LIMIT 10'

$testThree = new DBManager();
$testThree->select(
    'firstname',
    'email',
    'country',
    'city'
)->from('users')->where('id = 2399');
echo $testThree->result();
// this will display:
// 'SELECT firstname, email, country, city FROM users WHERE id = 2399'

?>

Question 5

Ein weiterer Weg zur statischen Methodenverkettung:

class Maker 
{
    private static $result      = null;
    private static $delimiter=".";
    private static $data        = [];

    public static function words($words)
    {
        if( !empty($words) && count($words) )
        {
            foreach ($words as $w)
            {
                self::$data[] = $w;
            }
        }        
        return new static;
    }

    public static function concate($delimiter)
    {
        self::$delimiter = $delimiter;
        foreach (self::$data as $d)
        {
            self::$result .= $d.$delimiter;
        }
        return new static;
    }

    public static function get()
    {
        return rtrim(self::$result, self::$delimiter);
    }    
}

Berufung

echo Maker::words(['foo', 'bob', 'bar'])->concate('-')->get();

echo "<br />";

echo Maker::words(['foo', 'bob', 'bar'])->concate('>')->get();

Question 6

Methodenverkettung bedeutet, dass Sie Methodenaufrufe verketten können:

$object->method1()->method2()->method3()

Das bedeutet, dass Methode1() ein Objekt zurückgeben muss und Methode2() das Ergebnis von Methode1() erhält. Method2() übergibt dann den Rückgabewert an method3().

Guter Artikel: http://www.talkphp.com/advanced-php-programming/1163-php5-method-chaining.html

Question 7

Es gibt 49 Codezeilen, mit denen Sie Methoden wie folgt über Arrays verketten können:

$fruits = new Arr(array("lemon", "orange", "banana", "apple"));
$fruits->change_key_case(CASE_UPPER)->filter()->walk(function($value,$key) {
     echo $key.': '.$value."\r\n";
});

Sehen Sie sich diesen Artikel an, der Ihnen zeigt, wie Sie alle siebzig array_-Funktionen von PHP verketten.

http://domexception.blogspot.fi/2013/08/php-magic-methods-and-arrayobject.html

Question 8

Eine fließende Schnittstelle ermöglicht es Ihnen, Methodenaufrufe zu verketten, was zu weniger typisierten Zeichen führt, wenn Sie mehrere Operationen auf dasselbe Objekt anwenden.

class Bill { 

    public $dinner    = 20;

    public $desserts  = 5;

    public $bill;

    public function dinner( $person ) {
        $this->bill += $this->dinner * $person;
        return $this;
    }
    public function dessert( $person ) {
        $this->bill += $this->desserts * $person;
        return $this;
    }
}

$bill = new Bill();

echo $bill->dinner( 2 )->dessert( 3 )->bill;