Problem children all come from another world, OVA. A brief discussion on the practical application of PHP closure features.

Well, in fact, it is possible in most cases, but some aspects are still very troubling. Let’s talk about it slowly.
Many languages ​​provide very elegant and beautiful methods for 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 annotation: The original author is relatively ignorant, and I don’t understand Groovy and Scala languages, so I will add the Javascript implementation here.
Let me explain before starting, this example is just to illustrate the point, and does not take into account other factors such as performance.
"Shop around"
Start with a simple example, with the following array:
$nums = array(10, 20, 30, 40); You need to find the items in the array that are greater than 15. 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 Scala language
val res = nums filter (_ > 15) Translation Note : If Javascript 1.6 is used, it will be as follows
var res = nums.filter(function(c){return c > 15}); Because the loop operation has been abstracted, you can see that Groovy and Scala (and Javascript) are all beautiful It 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 advanced methods than Scala in this regard It has more characters, but is shorter and easier to read than the previous example.
By the way, the above PHP code actually uses Lambda analysis 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 the value of a variable 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 very 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 come into play to solve this "boring problem" that seems to have a tendency to self-harm.
ArrayObject – an 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”, for example
$res = new ArrayObject(array( 10, 20, 30, 40));foreach ($res as $v) { echo "$vn";}ArrayObject is a built-in class, so you can encapsulate it like other class operations.
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 way? 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 added 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.
Game
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 syntax features that were added later (remember Java’s Generics feature back then? And the PHP OOP features in previous years), they all take time to run in and finally 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( The difference between 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 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).
Experience of an unreliable blogger
To be honest, although I knew about the proposed new closures and other functions before PHP5.0, after seeing the closures and Lambda functions provided by PHP5.3, my original expectations were different. There are still some discrepancies.
Even compared to the familiar JavaScript, PHP's closures seem to me to be the product of the mentality of "other languages ​​have them, so I have to have them too".
But as mentioned above, compared to other dynamic languages ​​such as JavaScript, PHP is different from other development languages ​​due to its own application and implementation philosophy.
Therefore, the calling and implementation methods of certain features will be different, which will inevitably make people who are familiar with other languages ​​with similar functions feel uncomfortable.
It has been less than half a year since PHP5.3 was launched. Compared with dynamic languages ​​such as JavaScript that already have closures and other features, it naturally seems very immature.
At the same time, the majority of developers are still holding a wait-and-see attitude towards the new features provided by PHP5.3, including closures.PHP's closure feature still exists in the laboratory. Its application in actual development requires not only breakthroughs in language features, but also tests in terms of efficiency, security, etc.
But I believe that, as the original author said, as the PHP version advances, PHP closure applications will become more and more frequent. Just like the conversion from PHP4 to PHP5, adapting to the new features of the language is actually a painful and joyful process.

The above introduces the problem children all come from another world OVA and briefly discusses the problems in the practical application of PHP closure features, including the content that problem children all come from another world OVA. I hope it will be helpful to friends who are interested in PHP tutorials.