Enchaînement de méthodes PHP ou interface fluide ?

Question

J'utilise PHP 5 et j'ai entendu parler d'une nouvelle fonctionnalité de l'approche orientée objet, appelée "chaînage de méthodes". Qu'est-ce que c'est exactement ? Comment puis-je l'implémenter ?

Answer 1

C'est assez simple, vraiment. Vous avez une série de méthodes du mutateur qui renvoient tous l'objet original (ou autre). De cette façon, vous pouvez continuer à appeler des méthodes sur l'objet retourné.

<?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();

Cela donne "ab".

Essayez-le en ligne !

Answer 2

En gros, vous prenez un objet :

$obj = new ObjectWithChainableMethods();

Appelez une méthode qui fait effectivement un return $this; à la fin :

$obj->doSomething();

Puisqu'elle renvoie le même objet, ou plutôt, une référence au même objet, vous pouvez continuer à appeler des méthodes de la même classe à partir de la valeur de retour, comme ceci :

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

C'est tout, vraiment. Deux choses importantes :

1. Comme vous l'avez noté, il s'agit de PHP 5 uniquement. Il ne fonctionnera pas correctement en PHP 4 car il renvoie des objets par valeur et cela signifie que vous appelez des méthodes sur différentes copies d'un objet, ce qui casserait votre code.

2. Encore une fois, vous devez retourner l'objet dans vos méthodes chaînables :

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

Answer 3

Essayez ce 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'

?>

Answer 4

Une autre façon d'enchaîner les méthodes statiques :

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

Appel à

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

echo "<br />";

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

Answer 5

Le chaînage de méthodes signifie que vous pouvez enchaîner les appels de méthodes :

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

Cela signifie que la méthode1() doit retourner un objet, et que la méthode2() reçoit le résultat de la méthode1(). La méthode2() transmet ensuite la valeur de retour à la méthode3().

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