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 is it possible to achieve the following writing method?

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

Let’s try it now.

Chain operation, to put it bluntly, is actually a method of calling objects in a chain. 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. Let’s implement this first:

1 class String 2 { 3 public $value; 4 5 public function __construct($str=null) 6  { 7 $this->value = $str; 8  } 9 }

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:

 1 class String  2 {  3 public $value;  4  5 public function __construct($str=null)  6  {  7 $this->value = $str;  8  }  9 10 public function __call($name, $args) 11  { 12 $this->value = call_user_func($name, $this->value, $args[0]); 13 return $this; 14  } 15 }

Tested:

1 $str = new String('01389'); 2 echo $str->trim('0')->value;

The results are 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 (here, trim), and the last two are the 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() processing on line 12 After completing the string, reassign the value attribute, and then return the reference of the current object, 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:

 1 class String  2 {  3 public $value;  4  5 public function __construct($str=null)  6  {  7 $this->value = $str;  8  }  9 10 public function __call($name, $args) 11  { 12 $this->value = call_user_func($name, $this->value, $args[0]); 13 return $this; 14  } 15 16 public function strlen() 17  { 18 return strlen($this->value); 19  } 20 }

Tested:

1 $str = new String('01389'); 2 echo $str->strlen();

Result:

Chain operation:

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

Result:

At this point, this article should have ended. However, after thinking about it, I found that chain operations can be achieved without using the __call() method. The following is the implementation without __call():

 1 class String  2 {  3 public $value;  4  5 public function __construct($str=null)  6  {  7 $this->value = $str;  8  }  9 10 public function trim($t) 11  { 12 $this->value = trim($this->value, $t); 13 return $this; 14  } 15 16 public function strlen() 17  { 18 return strlen($this->value); 19  } 20 }

The key to chain operations is to return $this after completing the operation.

In addition, this article was inspired by this article in the garden. It replaced the call_user_func() implementation with call_user_func_array() and modified the __call() method as follows.

1 public function __call($name, $args) 2  { 3 array_unshift($args, $this->value); 4 $this->value = call_user_func_array($name, $args); 5 return $this; 6 }

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 (the __construct() method is also).

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.