Description of the practical application of PHP closure features

The new version of PHP follows many new features, one of the more eye-catching features is the support for closures. So in the future, can we write very cool code like those guys who write Ruby, Javascript and other "high-tech languages"?

Well, in fact, it is possible in most cases, but some aspects are still very disturbing. Let’s talk about it slowly.
Many multiple languages provide very elegant and beautiful methods of operating arrays. In the following example, the closure function provided by PHP5.3 and other languages ​​will be used to show how to "objectively" operate iterable arrays.
Translation Note: The author of the original article is relatively ignorant. I don’t know Groovy and Scala language, so I add the Javascript implementation here.
Let me explain before starting. This example is only to illustrate the point and does not take into account other factors such as performance.

"Shop around"

Let's start with a simple example, with the following array:
$nums = array(10, 20, 30, 40 );Need to find items greater than 15 in the array. Then, without considering closure, we might write like this:
$res = array();foreach ($nums as $n) { if ($n > 15) { $res[] = $ n; }}If the language itself has closure support, then it may be written like this (Groovy language)
def res = nums.findAll { it > 15 } or use the Scala language
val res = nums filter (_ > 15) Translation Note: In Javascript 1.6, it will be as follows
var res = nums.filter(function(c){return c > 15}); Because the loop operation has been abstracted, So you can see that Groovy, Scala (and Javascript) are all very beautiful and can be done in one line.
Of course, if you use the closure of PHP5.3, you can also do it
$res = array_filter($nums, function($v) { return $v > 15; }) ;PHP uses more characters than Scala for this, but it's shorter and easier to read than the previous example.

By the way, the above PHP code actually uses Lambda parsing and is not a real closure. This is not the focus of our current attention. For detailed information on PHP closures and Lambda parsing, please refer here.
It seems to be pretty good so far, so let’s increase the difficulty of the problem: find all items greater than 15, then multiply by 2 and add a certain variable value in the scope before returning.

Groovy implementation:
def x = 1def res = nums .findAll { it > 15 } .collect { it * 2 + x }Scala implementation:
val x = 1val res = nums filter (_ > 15) map (_ * 2 + x) translation annotation, Javascript implementation:
var i = 1;var res = nums.filter(function(c){return c > 15}). map(function(c){return c * 2 + i}); and PHP:
$x = 1;$res = array_map( function($v) use ($x) { return $v * 2 + $x; }, array_filter( $nums, function($v) { return $v > 15; })); In terms of code size, it seems that PHP is now different from other languages. Leaving aside the literal aesthetics of the code, there is an additional problem with the PHP code above.
For example, what if you need to use array keys instead of values ​​for comparison? Yes, the above code cannot be done. Also, syntactically speaking, the above code is very difficult to read.

Back to nature, you still have to return to the old-fashioned way of thinking to solve the problem:
$x = 1;$res = array();foreach ($nums as $n) { if ($n > ; 15) { $res[] = $n * 2 + $x; }} Phew, this looks clear again. But at this time, you may be confused again: "Why bother messing around? Isn't this just an array operation?".
Yes, the best is yet to come. At this time, it is time to let some advanced features of PHP appear to solve this "boring problem" that seems to have a tendency to self-harm.

ArrayObject - Encapsulation of arrays
PHP has a standard library called SPL, which contains a class called ArrayObject, which can provide the function of "operating classes like arrays", such as
$res = new ArrayObject(array(10, 20, 30, 40));foreach ($res as $v) { echo "$vn";}ArrayObject is a built-in class, so you can operate it like other classes Encapsulate it.

Arr - sugar coating

Now that we have the features of ArrayObject and closures, we can start trying to encapsulate it:
class Arr extends ArrayObject { static function make($array) { return new self($array); } function map($func) { $res = new self(); foreach ($this as $k => $v) { $res[ $k] = $func($k, $v); } return $res; } function filter($func) { $res = new self(); foreach ($this as $k => $v) { if ($func($k, $v)) { $res[$k] = $v; } } return $res; }}Okay, everything is ready. The rewritten PHP code below can solve the problems mentioned above, and looks "almost" syntactically:

$res = Arr::make($nums) ->filter(function($k, $v) { return $v > 15; }) ->map(function($k, $v) { return $ v * 2; });How is the above code different from the traditional method? First, they can be recursive and chain calls, so more similar operations can be added.

At the same time, the keys and values ​​of the array can be manipulated respectively through the two parameters of the callback - $k corresponds to the key and $v corresponds to the value. This allows us to use key values ​​in closures, which is not possible with the traditional PHP function array_filter.
Another additional benefit is more consistent API calls. Using traditional PHP function operations, their first parameter may be a closure, or an array, or multiple arrays... Anyway, who knows?
Here is the complete source code of the Arr class, which also contains other useful functions (similar to reduce and walk). In fact, their implementation is similar to the code.

游戏

This question is actually difficult to answer - it depends on many factors such as the context of the code and the programmer himself. In fact, when I first saw PHP's closure implementation, I felt like I was back in the Java days long ago, when I started using anonymous inner classes to implement closures. Of course, this can be done, but it seems superfluous. There is nothing wrong with PHP closures, but its implementation and syntax confuse me.
Other languages ​​with closure features, they can call closures very conveniently and have elegant syntax. In the example above, using a traditional loop in Scala would also work, but would you write it this way? On the other hand, some people say that the above problem can also be achieved using PHP closures, but would you generally write it like this?
It is certain that PHP closures can be a sharp saber in some situations (such as delayed execution and resource calls), but they are a bit difficult in the face of traditional iteration and array operations. Don’t be discouraged. No matter what, the most important thing is to go back to basics and write compatible, clean code and APIs.

Conclusion

Like all grammatical features added later (remember the Generics feature of Java back then? And the PHP OOP feature of previous years), they all require Time to break in and eventually stabilize. As PHP5.3 and even PHP6 become more popular in the future, I believe that more and more techniques and features will be gradually discovered by smart programmers in the near future.
Go back to the title at the beginning of the original article and compare
$res = Arr::make($nums) ->filter(function($k, $v) { return $v > 15; }) - >map(function($k, $v) { return $v * 2; }); and
val res = nums filter (_ > 15) map (_ * 2). In the final analysis, they are just syntax. Essentially, they solve the same problem by different approaches. The application characteristics of programming languages ​​are different, so naturally it is impossible to compare which one is better and which one is worse.
Finally, here are the code examples from this article. I believe you can find more insights on how to use PHP for functional iteration (of course not only these).

The above is the detailed content of Description of the practical application of PHP closure features. For more information, please follow other related articles on the PHP Chinese website!