Closures and lambda functions in PHP vs. JavaScript
JavaScript and PHP support both lambda functions and closures. But the terms are poorly understood in both programming languages and are often confused with each other.
Lambda functions
Also called anonymous functions. They refer to functions that can be called without being bound to an identifier. One of their purposes is to be passed as arguments. The Lambda name was introduced by Alonzo Church, inventor of lambda calculus in 1936. In lambda calculus all functions are anonymous.
JavaScript
In JavaScript lambdas are part of the standard set and there are the preferred method of defining functions.
For instance:
1var add = function (a, b) {
2 return a + b;
3}
4alert(add(1, 2)); // 3
Lambda functions are used almost in any context when it comes to JavaScript, like:
1window.onload = function (e) {
2 alert('The page has loaded!');
3}
PHP
In PHP, lambda functions were introduced in version 4.0.1 using create_function. In version 5.3+ a similar syntax to JavaScript was added, a much more readable and elegant way of defining a function.
This means that in PHP there are two ways of creating a lambda function:
1// PHP 4.0.1+
2$add = create_function('$a, $b', 'return $a + $b;');
3
4// vs.
5
6// PHP 5.3+
7$add = function ($a, $b) {
8 return $a + $b;
9};
10
11echo $a(1,2); // 3
Lambda functions can be used as parameter for other functions, such as usort:
1$array = array(4, 3, 5, 1, 2);
2usort($array, function ($a, $b) {
3 if ($a == $b) {
4 return 0;
5 }
6 return ($a < $b) ? -1 : 1;
7});
Even more, PHP 5.3+ allows calling an object as a anonymous function:
1class test {
2 function __invoke($a) {
3 echo $a;
4 }
5}
6$a = new test();
7$a('test'); // 'test'
Closures
The closure is really the misunderstood concept of the two. In general confusion appears because closures may involve lambda functions. A closure refers to the ability of a function/object to access the scope in which it was created even if the parent function has ended it’s execution and returned. In other words, the function/object returned by a closure is running in the scope in which it was defined.
In JavaScript the notion of closure is part of the standard arsenal, because the language is not based on the traditional object model, but rather on prototypes and functions. But JavaScript has some traditional object model parts, like the fact that you can use “new” to construct an object based on a function that plays the role of a class. In PHP closures are more of an new way to approach problems, because PHP is part of the traditional object model family.
JavaScript
In JavaScript the notion of closure is widely used, it’s so popular because JavaScript is not a traditional object orientated language, but rather a functional one, based on prototype inheritance.
JavaScript doesn’t have Public, Private and Protected, but rather only Public and Private and objects an inherit from each other, without using classes.
Another issue is the scope, because the global scope is used by default. This issues can be fixed in an elegant fashion using closures:
1var closure = function () {
2 var sum = 0;
3 return {
4 add: function (nr) {
5 sum += nr;
6 },
7 getSum: function () {
8 return sum;
9 }
10 }
11}();
12
13closure.add(1);
14closure.add(2);
15console.log(closure.getSum());
In the example above, sum is a private property and in theory can only be accessed and modified by the closure function. The interesting part is that the parentheses from the end of the function definition, signify that this function will be immediately executed and therefore will return the result which is an object. At this point the original function will only exist for serving the return object, encapsulating therefor the private variable.
Although the function has finished execution, through this closure the returned object can still access the variables defined in the function scope, because that was the environment in which it was created.
This becomes even more interesting when a function returns another function:
1var counter = function () {
2 var counter = 0;
3 console.log('in closure');
4 return function () {
5 console.log('in the anonymous function');
6 return ++counter;
7 };
8};
9var counter1 = counter();
10
11console.log(counter1()); // 1
12
13var counter2 = counter();
14console.log(counter2()); // 1
15console.log(counter1()); // 2
The output will be:
1in closure
2in the anonymous function
31
4in closure
5in the anonymous function
61
7in the anonymous function
82
What actually happens is that the first function is executed and returns an anonymous function that can still access the environment in which it was created. In my opinion this is where the confusion between closures and lambda functions comes from, because a function returns another function.
The difference between examples is that in the first one the closure function executes immediately, and in the second example when counter is executed it’s returning a result that is actually a function definition, which in turn can be executed. Of course the second example can be modified to act just like in the first example using parenthesis.
PHP
As I said above, the notion of closure in PHP is not as important as in JavaScript.
Considering that lambda functions are available in the language since version 4, closures only appeared with PHP 5.3+.
Because of the block scope nature of PHP, there is a better encapsulation but there is a lot less flexibility compared to JavaScript. Basically in PHP you must specify using the use instruction what will the anonymous function be able to access from the closure scope.
1function closure () {
2 $c = 0;
3 return function ($a) use (&$c) {
4 $c += $a;
5 echo $a . ', ' . $c . PHP_EOL;
6 };
7}
8
9$closure = closure();
10
11$closure(1);
12$closure(2);
Unlike JavaScript, in PHP closures can not return objects, or rather the object can not be bound to the scope in which it was created, unless you send the variables as a reference to the constructor, in which case is not very elegant and I can’t imagine a scenario that would absolutely need closure for this.
Like in the JavaScript examples, instead of parentheses “()” at the end of the function, in PHP to run a function immediately after defining it call_user_func() or call_user_func_array() can be used:
1$closure = call_user_func(function () {
2 $c = 0;
3 return function ($a) use (&$c) {
4 $c += $a;
5 echo $a . ', ' . $c . PHP_EOL;
6
7 };
8});
9
10$closure(1);
11$closure(2);