Watch out when 'importing' variables to a closure's scope -- it's easy to miss / forget that they are actually being *copied* into the closure's scope, rather than just being made available.
So you will need to explicitly pass them in by reference if your closure cares about their contents over time:
<?php
$result = 0;
$one = function()
{ var_dump($result); };
$two = function() use ($result)
{ var_dump($result); };
$three = function() use (&$result)
{ var_dump($result); };
$result++;
$one(); // outputs NULL: $result is not in scope
$two(); // outputs int(0): $result was copied
$three(); // outputs int(1)
?>
Another less trivial example with objects (what I actually tripped up on):
<?php
//set up variable in advance
$myInstance = null;
$broken = function() uses ($myInstance)
{
if(!empty($myInstance)) $myInstance->doSomething();
};
$working = function() uses (&$myInstance)
{
if(!empty($myInstance)) $myInstance->doSomething();
}
//$myInstance might be instantiated, might not be
if(SomeBusinessLogic::worked() == true)
{
$myInstance = new myClass();
}
$broken(); // will never do anything: $myInstance will ALWAYS be null inside this closure.
$working(); // will call doSomething if $myInstance is instantiated
?>
Anonymous functions
Anonymous functions, also known as closures, allow the
creation of functions which have no specified name. They are most useful as
the value of callable
parameters, but they have many other uses.
Anonymous functions are implemented using the Closure class.
Example #1 Anonymous function example
<?php
echo preg_replace_callback('~-([a-z])~', function ($match) {
return strtoupper($match[1]);
}, 'hello-world');
// outputs helloWorld
?>
Closures can also be used as the values of variables; PHP automatically converts such expressions into instances of the Closure internal class. Assigning a closure to a variable uses the same syntax as any other assignment, including the trailing semicolon:
Example #2 Anonymous function variable assignment example
<?php
$greet = function($name)
{
printf("Hello %s\r\n", $name);
};
$greet('World');
$greet('PHP');
?>
Closures may also inherit variables from the parent scope. Any such
variables must be passed to the use language construct.
As of PHP 7.1, these variables must not include superglobals,
$this, or variables with the same name as a parameter.
Example #3 Inheriting variables from the parent scope
<?php
$message = 'hello';
// No "use"
$example = function () {
var_dump($message);
};
$example();
// Inherit $message
$example = function () use ($message) {
var_dump($message);
};
$example();
// Inherited variable's value is from when the function
// is defined, not when called
$message = 'world';
$example();
// Reset message
$message = 'hello';
// Inherit by-reference
$example = function () use (&$message) {
var_dump($message);
};
$example();
// The changed value in the parent scope
// is reflected inside the function call
$message = 'world';
$example();
// Closures can also accept regular arguments
$example = function ($arg) use ($message) {
var_dump($arg . ' ' . $message);
};
$example("hello");
?>
The above example will output something similar to:
Notice: Undefined variable: message in /example.php on line 6 NULL string(5) "hello" string(5) "hello" string(5) "hello" string(5) "world" string(11) "hello world"
As of PHP 8.0.0, the list of scope-inherited variables may include a trailing comma, which will be ignored.
Inheriting variables from the parent scope is not the same as using global variables. Global variables exist in the global scope, which is the same no matter what function is executing. The parent scope of a closure is the function in which the closure was declared (not necessarily the function it was called from). See the following example:
Example #4 Closures and scoping
<?php
// A basic shopping cart which contains a list of added products
// and the quantity of each product. Includes a method which
// calculates the total price of the items in the cart using a
// closure as a callback.
class Cart
{
const PRICE_BUTTER = 1.00;
const PRICE_MILK = 3.00;
const PRICE_EGGS = 6.95;
protected $products = array();
public function add($product, $quantity)
{
$this->products[$product] = $quantity;
}
public function getQuantity($product)
{
return isset($this->products[$product]) ? $this->products[$product] :
FALSE;
}
public function getTotal($tax)
{
$total = 0.00;
$callback =
function ($quantity, $product) use ($tax, &$total)
{
$pricePerItem = constant(__CLASS__ . "::PRICE_" .
strtoupper($product));
$total += ($pricePerItem * $quantity) * ($tax + 1.0);
};
array_walk($this->products, $callback);
return round($total, 2);
}
}
$my_cart = new Cart;
// Add some items to the cart
$my_cart->add('butter', 1);
$my_cart->add('milk', 3);
$my_cart->add('eggs', 6);
// Print the total with a 5% sales tax.
print $my_cart->getTotal(0.05) . "\n";
// The result is 54.29
?>
Example #5 Automatic binding of $this
<?php
class Test
{
public function testing()
{
return function() {
var_dump($this);
};
}
}
$object = new Test;
$function = $object->testing();
$function();
?>
The above example will output:
object(Test)#1 (0) {
}
When declared in the context of a class, the current class is
automatically bound to it, making $this available
inside of the function's scope. If this automatic binding of the current
class is not wanted, then
static anonymous
functions may be used instead.
Static anonymous functions
Anonymous functions may be declared statically. This prevents them from having the current class automatically bound to them. Objects may also not be bound to them at runtime.
Example #6 Attempting to use $this inside a static anonymous function
<?php
class Foo
{
function __construct()
{
$func = static function() {
var_dump($this);
};
$func();
}
};
new Foo();
?>
The above example will output:
Notice: Undefined variable: this in %s on line %d NULL
Example #7 Attempting to bind an object to a static anonymous function
<?php
$func = static function() {
// function body
};
$func = $func->bindTo(new StdClass);
$func();
?>
The above example will output:
Warning: Cannot bind an instance to a static closure in %s on line %d
Changelog
| Version | Description |
|---|---|
| 7.1.0 | Anonymous functions may not close over superglobals, $this, or any variable with the same name as a parameter. |
Notes
Note: It is possible to use func_num_args(), func_get_arg(), and func_get_args() from within a closure.
add a note
User Contributed Notes 40 notes
orls ¶
13 years ago
mike at blueroot dot co dot uk ¶
14 years ago
To recursively call a closure, use this code.
<?php
$recursive = function () use (&$recursive){
// The function is now available as $recursive
}
?>
This DOES NOT WORK
<?php
$recursive = function () use ($recursive){
// The function is now available as $recursive
}
?>
dexen dot devries at gmail dot com ¶
5 years ago
Every instance of a lambda has own instance of static variables. This provides for great event handlers, accumulators, etc., etc.
Creating new lambda with function() { ... }; expression creates new instance of its static variables. Assigning a lambda to a variable does not create a new instance. A lambda is object of class Closure, and assigning lambdas to variables has the same semantics as assigning object instance to variables.
Example script: $a and $b have separate instances of static variables, thus produce different output. However $b and $c share their instance of static variables - because $c is refers to the same object of class Closure as $b - thus produce the same output.
#!/usr/bin/env php
<?php
function generate_lambda() : Closure
{
# creates new instance of lambda
return function($v = null) {
static $stored;
if ($v !== null)
$stored = $v;
return $stored;
};
}
$a = generate_lambda(); # creates new instance of statics
$b = generate_lambda(); # creates new instance of statics
$c = $b; # uses the same instance of statics as $b
$a('test AAA');
$b('test BBB');
$c('test CCC'); # this overwrites content held by $b, because it refers to the same object
var_dump([ $a(), $b(), $c() ]);
?>
This test script outputs:
array(3) {
[0]=>
string(8) "test AAA"
[1]=>
string(8) "test CCC"
[2]=>
string(8) "test CCC"
}
fabiolimasouto at gmail dot com ¶
13 years ago
You may have been disapointed if you tried to call a closure stored in an instance variable as you would regularly do with methods:
<?php
$obj = new StdClass();
$obj->func = function(){
echo "hello";
};
//$obj->func(); // doesn't work! php tries to match an instance method called "func" that is not defined in the original class' signature
// you have to do this instead:
$func = $obj->func;
$func();
// or:
call_user_func($obj->func);
// however, you might wanna check this out:
$array['func'] = function(){
echo "hello";
};
$array['func'](); // it works! i discovered that just recently ;)
?>
Now, coming back to the problem of assigning functions/methods "on the fly" to an object and being able to call them as if they were regular methods, you could trick php with this lawbreaker-code:
<?php
class test{
private $functions = array();
private $vars = array();
function __set($name,$data)
{
if(is_callable($data))
$this->functions[$name] = $data;
else
$this->vars[$name] = $data;
}
function __get($name)
{
if(isset($this->vars[$name]))
return $this->vars[$name];
}
function __call($method,$args)
{
if(isset($this->functions[$method]))
{
call_user_func_array($this->functions[$method],$args);
} else {
// error out
}
}
}
// LET'S BREAK SOME LAW NOW!
$obj = new test;
$obj->sayHelloWithMyName = function($name){
echo "Hello $name!";
};
$obj->sayHelloWithMyName('Fabio'); // Hello Fabio!
// THE OLD WAY (NON-CLOSURE) ALSO WORKS:
function sayHello()
{
echo "Hello!";
}
$obj->justSayHello = 'sayHello';
$obj->justSayHello(); // Hello!
?>
NOTICE: of course this is very bad practice since you cannot refere to protected or private fields/methods inside these pseudo "methods" as they are not instance methods at all but rather ordinary functions/closures assigned to the object's instance variables "on the fly". But I hope you've enjoyed the jurney ;)
toonitw at gmail dot com ¶
6 years ago
As of PHP 7.0, you can use IIFE(Immediately-invoked function expression) by wrapping your anonymous function with ().
<?php
$type = 'number';
var_dump( ...( function() use ($type) {
if ($type=='number') return [1,2,3];
else if ($type=='alphabet') return ['a','b','c'];
} )() );
?>
cHao ¶
10 years ago
In case you were wondering (cause i was), anonymous functions can return references just like named functions can. Simply use the & the same way you would for a named function...right after the `function` keyword (and right before the nonexistent name).
<?php
$value = 0;
$fn = function &() use (&$value) { return $value; };
$x =& $fn();
var_dump($x, $value); // 'int(0)', 'int(0)'
++$x;
var_dump($x, $value); // 'int(1)', 'int(1)'
erolmon dot kskn at gmail dot com ¶
8 years ago
<?php
/*
(string) $name Name of the function that you will add to class.
Usage : $Foo->add(function(){},$name);
This will add a public function in Foo Class.
*/
class Foo
{
public function add($func,$name)
{
$this->{$name} = $func;
}
public function __call($func,$arguments){
call_user_func_array($this->{$func}, $arguments);
}
}
$Foo = new Foo();
$Foo->add(function(){
echo "Hello World";
},"helloWorldFunction");
$Foo->add(function($parameterone){
echo $parameterone;
},"exampleFunction");
$Foo->helloWorldFunction(); /*Output : Hello World*/
$Foo->exampleFunction("Hello PHP"); /*Output : Hello PHP*/
?>
Anonymous ¶
7 years ago
If you want to create and then immediately call a closure directly, in-line, and immediately get its return value (instead of the closure reference itself), then the proper syntax is as follows:
<?php
$a = 'foo'; $b = 'bar';
$test = (function() use($a,$b) { return $a . $b; })();
echo $test;
?>
As for why you would want to do that? Well, that's up to you. I'm sure there are some legitimate reasons. It's a pretty common pattern in some other famous scripting languages. But if you're doing this in PHP, you should think carefully and ask yourself if you really have a good reason for it, or if you should just go and re-structure your code instead. ;-)
housni dot yakoob at gmail dot com ¶
14 years ago
If you want to make sure that one of the parameters of your function is a Closure, you can use Type Hinting.
see: http://php.net/manual/en/language.oop5.typehinting.php
Example:
<?php
class TheRoot
{
public function poidh($param) {
echo "TheRoot $param!";
}
}
class Internet
{
# here, $my_closure must be of type object Closure
public function run_my_closure($bar, Closure $my_closure) {
$my_closure($bar);
}
}
$Internet = new Internet();
$Root = new TheRoot();
$Internet->run_my_closure($Root, function($Object) {
$Object->poidh(42);
});
?>
The above code simply yields:
"TheRoot 42!"
NOTE: If you are using namespaces, make sure you give a fully qualified namespace.
print_r() of Internet::run_my_closure's $my_closure
<?php
Closure Object
(
[parameter] => Array
(
[$Object] =>
)
)
?>
var_dump() of Internet::run_my_closure's $my_closure
<?php
object(Closure)#3 (1) {
["parameter"]=>
array(1) {
["$Object"]=>
string(10) ""
}
}
?>
rob at ubrio dot us ¶
14 years ago
You can always call protected members using the __call() method - similar to how you hack around this in Ruby using send.
<?php
class Fun
{
protected function debug($message)
{
echo "DEBUG: $message\n";
}
public function yield_something($callback)
{
return $callback("Soemthing!!");
}
public function having_fun()
{
$self =& $this;
return $this->yield_something(function($data) use (&$self)
{
$self->debug("Doing stuff to the data");
// do something with $data
$self->debug("Finished doing stuff with the data.");
});
}
// Ah-Ha!
public function __call($method, $args = array())
{
if(is_callable(array($this, $method)))
return call_user_func_array(array($this, $method), $args);
}
}
$fun = new Fun();
echo $fun->having_fun();
?>
a dot schaffhirt at sedna-soft dot de ¶
14 years ago
When using anonymous functions as properties in Classes, note that there are three name scopes: one for constants, one for properties and one for methods. That means, you can use the same name for a constant, for a property and for a method at a time.
Since a property can be also an anonymous function as of PHP 5.3.0, an oddity arises when they share the same name, not meaning that there would be any conflict.
Consider the following example:
<?php
class MyClass {
const member = 1;
public $member;
public function member () {
return "method 'member'";
}
public function __construct () {
$this->member = function () {
return "anonymous function 'member'";
};
}
}
header("Content-Type: text/plain");
$myObj = new MyClass();
var_dump(MyClass::member); // int(1)
var_dump($myObj->member); // object(Closure)#2 (0) {}
var_dump($myObj->member()); // string(15) "method 'member'"
$myMember = $myObj->member;
var_dump($myMember()); // string(27) "anonymous function 'member'"
?>
That means, regular method invocations work like expected and like before. The anonymous function instead, must be retrieved into a variable first (just like a property) and can only then be invoked.
Best regards,
Hayley Watson ¶
13 years ago
As an alternative to gabriel's recursive construction, you may instead assign the recursive function to a variable, and use it by reference, thus:
<?php
$fib = function($n)use(&$fib)
{
if($n == 0 || $n == 1) return 1;
return $fib($n - 1) + $fib($n - 2);
};
echo $fib(10);
?>
Hardly a sensible implementation of the Fibonacci sequence, but that's not the point! The point is that the variable needs to be used by reference, not value.
Without the '&', the anonymous function gets the value of $fib at the time the function is being created. But until the function has been created, $fib can't have it as a value! It's not until AFTER the function has been assigned to $fib that $fib can be used to call the function - but by then it's too late to pass its value to the function being created!
Using a reference resolves the dilemma: when called, the anonymous function will use $fib's current value, which will be the anonymous function itself.
At least, it will be if you don't reassign $fib to anything else between creating the function and calling it:
<?php
$fib = function($n)use(&$fib)
{
if($n == 0 || $n == 1) return 1;
return $fib($n - 1) + $fib($n - 2);
};
$lie = $fib;
$fib = function($n)
{
return 100;
};
echo $lie(10); // 200, because $fib(10 - 1) and $fib(10 - 2) both return 100.
?>
Of course, that's true of any variable: if you don't want its value to change, don't change its value.
All the usual scoping rules for variables still apply: a local variable in a function is a different variable from another one with the same name in another function:
<?php
$fib = function($n)use(&$fib)
{
if($n == 0 || $n == 1) return 1;
return $fib($n - 1) + $fib($n - 2);
};
$bark = function($f)
{
$fib = 'cake'; // A totally different variable from the $fib above.
return 2 * $f(5);
};
echo $bark($fib); // 16, twice the fifth Fibonacci number
?>
john at binkmail dot com ¶
7 years ago
PERFORMANCE BENCHMARK 2017!
I decided to compare a single, saved closure against constantly creating the same anonymous closure on every loop iteration. And I tried 10 million loop iterations, in PHP 7.0.14 from Dec 2016. Result:
a single saved closure kept in a variable and re-used (10000000 iterations): 1.3874590396881 seconds
new anonymous closure created each time (10000000 iterations): 2.8460240364075 seconds
In other words, over the course of 10 million iterations, creating the closure again during every iteration only added a total of "1.459 seconds" to the runtime. So that means that every creation of a new anonymous closure takes about 146 nanoseconds on my 7 years old dual-core laptop. I guess PHP keeps a cached "template" for the anonymous function and therefore doesn't need much time to create a new instance of the closure!
So you do NOT have to worry about constantly re-creating your anonymous closures over and over again in tight loops! At least not as of PHP 7! There is absolutely NO need to save an instance in a variable and re-use it. And not being restricted by that is a great thing, because it means you can feel free to use anonymous functions exactly where they matter, as opposed to defining them somewhere else in the code. :-)
jigar ¶
7 years ago
Will result in a "Parse error: syntax error, unexpected '[', expecting ',' or ')' ... "
<?php
$fruits = ['apples', 'oranges'];
$example = function () use ($fruits[0]) {
echo $fruits[0];
};
$example();
?>
Would have to do this:
<?php
$fruits = ['apples', 'oranges'];
$example = function () use ($fruits) {
echo $fruits[0]; // will echo 'apples'
};
$example();
?>
Or this instead:
<?php
$fruits = ['apples', 'oranges'];
$fruit = $fruits[0];
$example = function () use ($fruit) {
echo $fruit; // will echo 'apples'
};
$example();
rmckay at webaware dot com dot au ¶
10 years ago
Some hosts are installing the eAccelerator opcode cache with PHP 5.4, and current production versions of this opcode cache break closures. If you find that your nice, working closures break when you load your code to a hosted website, check for eAccelerator (e.g. by calling phpinfo() and checking the output).
Simple fixes include:
* disabling eAccelerator and opcode caching
* replacing eAccelerator with Zend's opcache
* reverting to PHP 5.3
Apparently, the eAccelerator project has solved this issue, but hosts move slowly so I recommend removing eAccelerator from the equation for now.
jake dot tunaley at berkeleyit dot com ¶
5 years ago
Beware of using $this in anonymous functions assigned to a static variable.
<?php
class Foo {
public function bar() {
static $anonymous = null;
if ($anonymous === null) {
// Expression is not allowed as static initializer workaround
$anonymous = function () {
return $this;
};
}
return $anonymous();
}
}
$a = new Foo();
$b = new Foo();
var_dump($a->bar() === $a); // True
var_dump($b->bar() === $a); // Also true
?>
In a static anonymous function, $this will be the value of whatever object instance that method was called on first.
To get the behaviour you're probably expecting, you need to pass the $this context into the function.
<?php
class Foo {
public function bar() {
static $anonymous = null;
if ($anonymous === null) {
// Expression is not allowed as static initializer workaround
$anonymous = function (self $thisObj) {
return $thisObj;
};
}
return $anonymous($this);
}
}
$a = new Foo();
$b = new Foo();
var_dump($a->bar() === $a); // True
var_dump($b->bar() === $a); // False
?>
gabriel dot totoliciu at ddsec dot net ¶
13 years ago
If you want to make a recursive closure, you will need to write this:
$some_var1="1";
$some_var2="2";
function($param1, $param2) use ($some_var1, $some_var2)
{
//some code here
call_user_func(__FUNCTION__, $other_param1, $other_param2);
//some code here
}
If you need to pass values by reference you should check out
http://www.php.net/manual/en/function.call-user-func.php
http://www.php.net/manual/en/function.call-user-func-array.php
If you're wondering if $some_var1 and $some_var2 are still visible by using the call_user_func, yes, they are available.
derkontrollfreak+9hy5l at gmail dot com ¶
10 years ago
Beware that since PHP 5.4 registering a Closure as an object property that has been instantiated in the same object scope will create a circular reference which prevents immediate object destruction:
<?php
class Test
{
private $closure;
public function __construct()
{
$this->closure = function () {
};
}
public function __destruct()
{
echo "destructed\n";
}
}
new Test;
echo "finished\n";
/*
* Result in PHP 5.3:
* ------------------
* destructed
* finished
*
* Result since PHP 5.4:
* ---------------------
* finished
* destructed
*/
?>
To circumvent this, you can instantiate the Closure in a static method:
<?php
public function __construct()
{
$this->closure = self::createClosure();
}
public static function createClosure()
{
return function () {
};
}
?>
ldrut ¶
12 years ago
A common way to avoid contaminating Javascript global space with unneeded variables is to move the code into an immediately called anonymous closure.
(function(){ ... })()
The equivalent way to do that in PHP 5.3+ is
call_user_func(function() use(closure-vars){ ... });
aaron at afloorabove dot com ¶
14 years ago
Anonymous functions are great for events!
<?php
class Event {
public static $events = array();
public static function bind($event, $callback, $obj = null) {
if (!self::$events[$event]) {
self::$events[$event] = array();
}
self::$events[$event][] = ($obj === null) ? $callback : array($obj, $callback);
}
public static function run($event) {
if (!self::$events[$event]) return;
foreach (self::$events[$event] as $callback) {
if (call_user_func($callback) === false) break;
}
}
}
function hello() {
echo "Hello from function hello()\n";
}
class Foo {
function hello() {
echo "Hello from foo->hello()\n";
}
}
class Bar {
function hello() {
echo "Hello from Bar::hello()\n";
}
}
$foo = new Foo();
// bind a global function to the 'test' event
Event::bind("test", "hello");
// bind an anonymous function
Event::bind("test", function() { echo "Hello from anonymous function\n"; });
// bind an class function on an instance
Event::bind("test", "hello", $foo);
// bind a static class function
Event::bind("test", "Bar::hello");
Event::run("test");
/* Output
Hello from function hello()
Hello from anonymous function
Hello from foo->hello()
Hello from Bar::hello()
*/
?>
varuninorbit at yahoo dot co dot in ¶
8 years ago
Here is a simple example to use clousers
<?php
function add($x,$y){
return $x+$y();
}
echo add(3,function(){
return 5;
});
?>
prints 8
reinaldorock at yahoo dot com dot br ¶
12 years ago
Using closure to encapsulate environment
<?php
$fib = function($n) use(&$fib) {
if($n == 0 || $n == 1) return 1;
return $fib($n - 1) + $fib($n - 2);
};
echo $fib(2) . "\n"; // 2
$lie = $fib;
$fib = function(){die('error');};//rewrite $fib variable
echo $lie(5); // error because $fib is referenced by closure
?>
Alternative Fibonacci implementation using a self called function like javascript to encapsulate references variables.
<?php
$fib = call_user_func(function(){
$fib = function($n) use(&$fib) {
if($n == 0 || $n == 1) return 1;
return $fib($n - 1) + $fib($n - 2);
};
return $fib;
});
echo $fib(2) . "\n";//2
$ok = $fib;
$fib = function(){die('error')};//rewrite $fib variable but don't referenced $fib used by closure
echo $ok(5);//result ok
?>
simon at generalflows dot com ¶
12 years ago
<?php
/*
* An example showing how to use closures to implement a Python-like decorator
* pattern.
*
* My goal was that you should be able to decorate a function with any
* other function, then call the decorated function directly:
*
* Define function: $foo = function($a, $b, $c, ...) {...}
* Define decorator: $decorator = function($func) {...}
* Decorate it: $foo = $decorator($foo)
* Call it: $foo($a, $b, $c, ...)
*
* This example show an authentication decorator for a service, using a simple
* mock session and mock service.
*/
session_start();
/*
* Define an example decorator. A decorator function should take the form:
* $decorator = function($func) {
* return function() use $func) {
* // Do something, then call the decorated function when needed:
* $args = func_get_args($func);
* call_user_func_array($func, $args);
* // Do something else.
* };
* };
*/
$authorise = function($func) {
return function() use ($func) {
if ($_SESSION['is_authorised'] == true) {
$args = func_get_args($func);
call_user_func_array($func, $args);
}
else {
echo "Access Denied";
}
};
};
/*
* Define a function to be decorated, in this example a mock service that
* need to be authorised.
*/
$service = function($foo) {
echo "Service returns: $foo";
};
/*
* Decorate it. Ensure you replace the origin function reference with the
* decorated function; ie just $authorise($service) won't work, so do
* $service = $authorise($service)
*/
$service = $authorise($service);
/*
* Establish mock authorisation, call the service; should get
* 'Service returns: test 1'.
*/
$_SESSION['is_authorised'] = true;
$service('test 1');
/*
* Remove mock authorisation, call the service; should get 'Access Denied'.
*/
$_SESSION['is_authorised'] = false;
$service('test 2');
?>
kdelux at gmail dot com ¶
13 years ago
Here is an example of one way to define, then use the variable ( $this ) in Closure functions. The code below explores all uses, and shows restrictions.
The most useful tool in this snippet is the requesting_class() function that will tell you which class is responsible for executing the current Closure().
Overview:
-----------------------
Successfully find calling object reference.
Successfully call $this(__invoke);
Successfully reference $$this->name;
Successfully call call_user_func(array($this, 'method'))
Failure: reference anything through $this->
Failure: $this->name = '';
Failure: $this->delfect();
<?php
function requesting_class()
{
foreach(debug_backtrace(true) as $stack){
if(isset($stack['object'])){
return $stack['object'];
}
}
}
class Person
{
public $name = '';
public $head = true;
public $feet = true;
public $deflected = false;
function __invoke($p){ return $this->$p; }
function __toString(){ return 'this'; } // test for reference
function __construct($name){ $this->name = $name; }
function deflect(){ $this->deflected = true; }
public function shoot()
{ // If customAttack is defined, use that as the shoot resut. Otherwise shoot feet
if(is_callable($this->customAttack)){
return call_user_func($this->customAttack);
}
$this->feet = false;
}
}
$p = new Person('Bob');
$p->customAttack =
function(){
echo $this; // Notice: Undefined variable: this
#$this = new Class() // FATAL ERROR
// Trick to assign the variable '$this'
extract(array('this' => requesting_class())); // Determine what class is responsible for making the call to Closure
var_dump( $this ); // Passive reference works
var_dump( $$this ); // Added to class: function __toString(){ return 'this'; }
$name = $this('name'); // Success
echo $name; // Outputs: Bob
echo '<br />';
echo $$this->name;
call_user_func_array(array($this, 'deflect'), array()); // SUCCESSFULLY CALLED
#$this->head = 0; //** FATAL ERROR: Using $this when not in object context
$$this->head = 0; // Successfully sets value
};
print_r($p);
$p->shoot();
print_r($p);
die();
?>
Anonymous ¶
14 years ago
If you want to check whether you're dealing with a closure specifically and not a string or array callback you can do this:
<?php
$isAClosure = is_callable($thing) && is_object($thing);
?>
assarte dot draven at gmail dot com ¶
10 years ago
You cannot use closures as a class variable member in its declaration like this:
<?php
class foo
{
public $bar = function() {
echo "baz";
};
}
?>
I don't know why but this will raise a
Parse error: syntax error, unexpected 'function' (T_FUNCTION)
(used PHP 5.4)
mail at mkharitonov dot net ¶
10 years ago
Some comparisons of PHP and JavaScript closures.
=== Example 1 (passing by value) ===
PHP code:
<?php
$aaa = 111;
$func = function() use($aaa){ print $aaa; };
$aaa = 222;
$func(); // Outputs "111"
?>
Similar JavaScript code:
<script type="text/javascript">
var aaa = 111;
var func = (function(aaa){ return function(){ alert(aaa); } })(aaa);
aaa = 222;
func(); // Outputs "111"
</script>
Be careful, following code is not similar to previous code:
<script type="text/javascript">
var aaa = 111;
var bbb = aaa;
var func = function(){ alert(bbb); };
aaa = 222;
func(); // Outputs "111", but only while "bbb" is not changed after function declaration
// And this technique is not working in loops:
var functions = [];
for (var i = 0; i < 2; i++)
{
var i2 = i;
functions.push(function(){ alert(i2); });
}
functions[0](); // Outputs "1", wrong!
functions[1](); // Outputs "1", ok
</script>
=== Example 2 (passing by reference) ===
PHP code:
<?php
$aaa = 111;
$func = function() use(&$aaa){ print $aaa; };
$aaa = 222;
$func(); // Outputs "222"
?>
Similar JavaScript code:
<script type="text/javascript">
var aaa = 111;
var func = function(){ alert(aaa); };
aaa = 222; // Outputs "222"
func();
</script>
marcellorvalle at gmail dot com ¶
11 years ago
I fell uncomfortable with php's way to pass callbacks ahead. It's just a personal opinion but i think the structure array($object, 'method') a little bit ugly. In some special cases i would like to do something more verbose, like that:
<?php
$sortedArray = ArrayServices::sort($arrayOfPerson, $sortPerson->byName);
?>
Here, "$sortPerson->byName" is a pointer to a function that receives 2 instances of Person and return true if the name of the first is "bigger" than the second. "ArrayServices::sort" is a function that can sort any kind of array using different criterias, it uses the function passed on the second parameter to compare two items on the array
I am able do that defining a simple abstract class which gives the ability to it's children to expose their methods as closures using __get() magic funtion.
<?php
abstract class ClosureExposerObject
{
public function __get($methodName)
{
if (is_callable(
array($this, $methodName)))
{
return function() use ($methodName)
{
$args = func_get_args();
return call_user_func_array(array($this, $methodName), $args);
};
}
else
{
$className = get_class($this);
throw new \BadMethodCallException("$method is not a callable at $className class.");
}
}
}
?>
Now it is possible to define a class SortPerson so that i could use it like in the first code snippet.
<?php
class SortPerson extends ClosureExposerObject
{
public function byName(Person p1, Person p2)
{
return p1->getName() > p2->getName();
}
public function byAge(Person p1, Person p2)
{
return p1->getAge() > p2->getAge();
}
public function bySurName(Person p1, Person p2)
(...)
}
?>
I just needed to extend ClosureExposerObject and do nothing more.
Some observations: SortPerson is a service class but i decided not to implement it with static methods. It is a personal matter but i really dont like to implement such small classes with statics. Also i have inverted some naming conventions (class names as substantives and methods as verbs) but in some very special cases i thing that it actually helps readability.
ohcc at 163 dot com ¶
7 years ago
Supported by PHP 7.0+ only.
<?php
(function($name){
echo 'My name is ' . $name;
})('Wu Xiancheng');
?>
martin dot partel at gmail dot com ¶
13 years ago
$this is currently (PHP 5.3.2) not usable directly with closures.
One can write:
<?php
$self = $this;
function () use ($self) { ... }
?>
but then the private/protected members of $this cannot be used inside the closure. This makes closures much less useful in OO code.
Until this is fixed, one can cheat using reflection:
<?php
class FullAccessWrapper
{
protected $_self;
protected $_refl;
public function __construct($self)
{
$this->_self = $self;
$this->_refl = new ReflectionObject($self);
}
public function __call($method, $args)
{
$mrefl = $this->_refl->getMethod($method);
$mrefl->setAccessible(true);
return $mrefl->invokeArgs($this->_self, $args);
}
public function __set($name, $value)
{
$prefl = $this->_refl->getProperty($name);
$prefl->setAccessible(true);
$prefl->setValue($this->_self, $value);
}
public function __get($name)
{
$prefl = $this->_refl->getProperty($name);
$prefl->setAccessible(true);
return $prefl->getValue($this->_self);
}
public function __isset($name)
{
$value = $this->__get($name);
return isset($value);
}
}
/**
* Usage:
* $self = giveAccess($this);
* function() use ($self) { $self->privateMember... }
*/
function giveAccess($obj)
{
return new FullAccessWrapper($obj);
}
// Example:
class Foo
{
private $x = 3;
private function f()
{
return 15;
}
public function getClosureUsingPrivates()
{
$self = giveAccess($this);
return function () use ($self) {
return $self->x * $self->f();
};
}
}
$foo = new Foo();
$closure = $foo->getClosureUsingPrivates();
echo $closure() . "\n"; // Prints 45 as expected
?>
Anonymous ¶
13 years ago
use() parameters are early binding - they use the variable's value at the point where the lambda function is declared, rather than the point where the lambda function is called (late binding).
If you want late binding put & before the variable inside use()
<?php
$fn = function () use (&$var) { echo $var; };
?>
Examples:
<?php
// problem 1: this should echo "Canada", not a php notice
$fn = function () use ($country) { echo $country . "\n"; };
$country = 'Canada';
$fn();
// problem 2: this should echo "Canada", not "UnitedStates"
$country = 'UnitedStates';
$fn = function () use ($country) { echo $country . "\n"; };
$country = 'Canada';
$fn();
// problem 3: this should echo "Canada", not "UnitedStates"
$country = (object)array('name' => 'UnitedStates');
$fn = function () use ($country) { echo $country->name . "\n"; };
$country = (object)array('name' => 'Canada');
$fn();
// problem 4: this outputs "Canada". if this outputs "Canada",
// then so should problem 2 above. otherwise this should be
// just as broken as problem 2 and be outputting "UnitedStates"
$country = (object)array('name' => 'UnitedStates');
$fn = function () use ($country) { echo $country->name . "\n"; };
$country->name = 'Canada';
$fn();
?>
see http://bugs.php.net/bug.php?id=50980
(I've just quoted from there, but if you want you can read there the whole feature request)
kukoman at pobox dot sk ¶
14 years ago
be aware of Fatal error: Using $this when not in object context when using in closures
http://wiki.php.net/rfc/closures/removal-of-this
mike at borft dot student dot utwente dot nl ¶
12 years ago
Since it is possible to assign closures to class variables, it is a shame it is not possible to call them directly. ie. the following does not work:
<?php
class foo {
public test;
public function __construct(){
$this->test = function($a) {
print "$a\n";
};
}
}
$f = new foo();
$f->test();
?>
However, it is possible using the magic __call function:
<?php
class foo {
public test;
public function __construct(){
$this->test = function($a) {
print "$a\n";
};
}
public function __call($method, $args){
if ( $this->{$method} instanceof Closure ) {
return call_user_func_array($this->{$method},$args);
} else {
return parent::__call($method, $args);
}
}
}
$f = new foo();
$f->test();
?>
it
Hope it helps someone ;)
ayon at hyurl dot com ¶
6 years ago
One way to call a anonymous function recursively is to use the USE keyword and pass a reference to the function itself:
<?php
$count = 1;
$add = function($count) use (&$add){
$count += 1;
if($count < 10) $count = $add($count); //recursive calling
return $count;
};
echo $add($count); //Will output 10 as expected
?>
ljackson at jjcons dot com ¶
14 years ago
appears kwilson at shuttlebox dot net that you may have just made unintended side effect. Note that adding the global $variable to your test function make the closure function echo second rather than first So the anonymous function works as expected with respect to globals.
<?php
$variable = "first";
$closure = function() {
global $variable;
echo $variable . "\n";
};
$closure();
function test($closure)
{
global $variable; //Note the scope added here
$variable = "second";
$closure();
}
test($closure);
?>
prints:
first
second
tested with php 5.3.1
andris at codeaid dot net ¶
10 years ago
Haven't seen it documented anywhere but PHP 5.4 now allows accessing private and protected members of an object if it's passed into a lambda function:
<?php
class Scope
{
protected $property = 'default';
// or even
// private $property = 'default';
public function run()
{
$self = $this;
$func = function() use ($self) {
$self->property = 'changed';
};
$func();
var_dump($this->property);
}
}
$scope = new Scope();
$scope->run();
?>
When running the file under PHP 5.3 you get the following error message:
* Fatal error: Cannot access protected property Scope::$property in ./file.php on line 11
PHP 5.4, however, does not complain and outputs "changed" as expected.
Not sure why it's like that but I suspect it has something to do with 5.4 supporting passing $this into lambda functions.
Speaking of which, something to remember is that the following won't work:
<?php
$func = function() use ($this) {
$this->property = 'changed';
};
?>
The error you'll get is:
* PHP Fatal error: Cannot use $this as lexical variable in ./file.php on line 9
You have to totally omit the use statement for it to work:
<?php
$func = function() {
$this->property = 'changed';
};
?>
anonymous ¶
13 years ago
Base dao class illustrating the usefulness of closures.
* Handles opening and closing of connections.
* Adds slashes sql
* Type checking of sql parameters and casts as appropriate
* Provides hook for processing of result set and emitting one or more objects.
* Provides hook for accessing underlying link and result objects.
<?php
define("userName","root");
define("password","root");
define("dbName","ahcdb");
define("hostName","localhost");
class BaseDao {
function getConnection() {
$link = mysql_connect(hostName, userName, password);
if (!$link)
die("Could not connect: " . mysql_error());
if (!mysql_select_db(dbName))
die("Could not select database: " . mysql_error());
return $link;
}
function setParams(& $sql, $params) {
if($params != null)
$sql = vsprintf($sql, array_map(function($n) {
if(is_int($n))
return (int)$n;
if(is_float($n))
return (float)$n;
if(is_string($n))
return "'".mysql_real_escape_string($n)."'";
return mysql_real_escape_string($n);
}, $params));
}
function executeQuery($sql, $params, $callback = null) {
$link = $this->getConnection();
$this->setParams($sql, $params);
$return = null;
if(($result = mysql_query($sql, $link)) != null)
if($callback != null)
$return = $callback($result, $link);
if($link != null)
mysql_close($link);
if(!$result)
die("Fatal Error: Invalid query '$sql' : " . mysql_error());
return $return;
}
function getList($sql, $params, $callback) {
return $this->executeQuery($sql, $params, function($result, $link) use ($callback) {
$idx = 0;
$list = array();
while ($row = mysql_fetch_assoc($result))
if($callback != null)
$list[$idx] = $callback($idx++, $row);
return $list;
});
}
function getSingle($sql, $params, $callback) {
return $this->executeQuery($sql, $params, function($result, $link) use ($callback) {
if ($row = mysql_fetch_assoc($result))
$obj = $callback($row);
return $obj;
});
}
}
class Example {
var $id;
var $name;
function Example($id, $name){
$this->id = $id;
$this->name = $name;
}
function setId($id){
$this->id = $id;
}
}
class ExampleDao extends BaseDao {
function getAll(){
return parent::getList("select * from nodes", null, function($idx, $row) {
return new Example($row["id"], $row["name"]);
});
}
function load($id){
return parent::getSingle("select * from nodes where id = %1\$s", array($id), function($row) {
return new Example($row["id"], $row["name"]);
});
}
function update($example){
return parent::executeQuery("update nodes set name = '' where id = -1", null, function($result, $link){
return $result;
});
}
function insert(& $example){
return parent::executeQuery("insert into nodes", null, function($result, $link) use ($example){
$id = mysql_insert_id($link);
$example->setId($id);
return $result;
});
}
}
$exampleDao = new ExampleDao();
$list = $exampleDao->getAll());
$exampleObject = $exampleDao->load(1));
$exampleDao->update($exampleObject);
?>
mcm dot matt at gmail dot com ¶
14 years ago
Example using uasort.
<?php
// Usual method.
function cmp($a, $b) {
return($a > $b);
}
uasort($array, 'cmp');
// New
uasort($array, function($a, $b) {
return($a > $b);
});
?>
Anonymous ¶
4 years ago
IIFE(Immediately-invoked function expression):
Before PHP 7.0, you can use it by wrapping your anonymous function with call_user_func().
<?php
$type = 'number';
var_dump( call_user_func( function() use ($type) {
if ($type=='number') return [1,2,3];
else if ($type=='alphabet') return ['a','b','c'];
} ) );
?>
Starting from PHP 7.0, you can use it by wrapping your anonymous function with ()().
<?php
$type = 'number';
var_dump( ( function() use ($type) {
if ($type=='number') return [1,2,3];
else if ($type=='alphabet') return ['a','b','c'];
} )() );
?>
lincoln dot du dot j at gmail dot com ¶
4 years ago
Recursive anonymous function with reference in use keyword
$r=function()use(&$r){static $i=10;echo $i.PHP_EOL;($i--)?$r():$i;};$r();
