Use php to implement a simple chain operation

Recently I am reading the book "php Core Technology and Best Practices". The first chapter of the book mentions that the __call() method can be used to implement a simple string chain operation. For example, the following filters the string and then searches for it. The length operation is generally written like this:

strlen(trim($str));

So can the following writing be achieved?

$str->trim()->strlen();

Let’s try it now.

Chain operation, to put it bluntly, is actually a chain method of calling object methods. Since you want to implement string chain operations, you must implement a string class and then call the object of this class. My expectations for the String class are as follows: (1) When I create the object, I can assign the string to a property of the object, and I can access this property to read the value; (2) I can call trim() and strlen( ) method; (3) I can also call the method $str->trim()->strlen() like this.

Item (1) above is the basic requirement for a string class. Implement this first:

class String
{
    public $value;

    public function __construct($str=null)
    {
        $this->value = $str;
    }
}

You can try:

1 $str = new String('01389');

2 echo $str->value;

Then look at item 2 , first implement $str->trim(), refer to the idea in the book: trigger the __call method and then execute call_user_func. The code is as follows:

class String
{
    public $value;

    public function __construct($str=null)
    {
        $this->value = $str;
    }

    public function __call($name, $args)
    {
        $this->value = call_user_func($name, $this->value, $args[0]);
        return $this;
    }
}

Tested:

1 $str = new String('01389');

2 echo $str->trim('0')->value;

The result is as follows:

What needs to be noted above is line 12: $this->value = call_user_func($name, $this->value, $args[0]); $name is the name of the callback function (that is, here trim), the last two are parameters of the callback function (tirm), do not reverse the order of the parameters. $args is an array, so you need to pay attention.

Strlen() must also be implemented in Article 2. At this time, line 13 in the above code is very critical: return $this; Its function is to call trim() on line 12 to process the string and then re- The value attribute is assigned a value, and then a reference to the current object is returned, so that other methods in the object can perform continuous operations on the attribute value, thus realizing chain operations. $str->strlen() is implemented as follows:

class String
{
    public $value;

    public function __construct($str=null)
    {
        $this->value = $str;
    }

    public function __call($name, $args)
    {
        $this->value = call_user_func($name, $this->value, $args[0]);
        return $this;
    }

    public function strlen()
    {
        return strlen($this->value);
    }
}

Tested:

1 $str = new String('01389');

2 echo $str->strlen();

Result:

Chain operation:

echo $str->trim('0')->strlen();

Result:

class String
{
    public $value;

    public function __construct($str=null)
    {
        $this->value = $str;
    }

    public function trim($t)
    {
        $this->value = trim($this->value, $t);
        return $this;
    }

    public function strlen()
    {
        return strlen($this->value);
    }
}

The key to chain operation is to finish the operation Finally, return $this.

In addition, this article is inspired by this article in the garden, replacing the call_user_func() implementation with call_user_func_array(), and modifying the __call() method as follows.

public function __call($name, $args)
    {
        array_unshift($args, $this->value);
        $this->value = call_user_func_array($name, $args);
        return $this;
    }

The effect is the same as the __call() method above, so the code seems to be more elegant than the previous implementation.

Summary:

__call() will be triggered when the object calls an inaccessible method, so it can realize the creation of dynamic methods of the class and realize the method overloading function of PHP, but it is actually a syntax sugar (__construct( ) method as well).

So if there is no syntax sugar such as __call(), can the creation of dynamic methods and chain operations be realized? I think it will involve the following aspects: whether the class method exists and can be called. This can be achieved using method_exists, is_callable, get_class_methods and other methods. In addition, assigning values ​​(initialization) to attributes when creating an object is syntax sugar. Convenient indeed, but not necessary. Let’s study it again when we have time.