A brief discussion on the problems of PHP closure feature in practical application_PHP Tutorial

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 Note: The original author is relatively incompetent. I don’t know Groovy and Scala language, so I add the Javascript implementation here.
Before I start, let me explain that 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 );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: For Javascript 1.6, it will be as follows
var res = nums.filter(function(c){return c > 15}); Because the loop operation has been abstracted, you can see Groovy, Scala (and Javascript) are both pretty 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 is used in this regard has more characters than Scala, 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.
So far it seems to be pretty good, so let’s increase the difficulty of the problem: find all items greater than 15, then multiply by 2 plus a certain variable value in the scope and then return.

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 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", 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 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 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 grammar. 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).

Unreliable blogger’s experience
Frankly speaking, although I knew about the proposed new closures and other functions before PHP5.0, I didn’t realize it after seeing PHP5.3 After providing the closure and Lambda functions, it is still somewhat different from the original psychological expectations.
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 with 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 familiar with other languages ​​with similar functions feel uncomfortable.

It has been less than half a year since PHP5.3 was launched. Compared with JavaScript and other dynamic languages ​​that already have features such as closures, it naturally appears to be 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.

http://www.bkjia.com/PHPjc/320720.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/320720.htmlTechArticleWell, in fact, it is possible in most cases, but some aspects are still very troubling. Let’s take a look. Tao Lai. Many languages ​​provide very elegant and beautiful methods of operating arrays...