Anonymous Functions in PHP 5.3 - Matthew Weier O’Phinney

Anonymous Functions in PHP 5.3

Matthew Weier O’Phinney

26 April 2011

Lambdas

• From “lambda calculus”

26 April 2011 Anonymous Functions in PHP 5.3 3

Lambdas

• Names of functions are merely a “convenience”, and
hence all functions are considered anonymous


Lambdas

• Names of functions are merely a “convenience”, and
hence all functions are considered anonymous
• Unless you’re using a true functional programming
language with ﬁrst-class functions, most likely you’re
simply using anonymous functions, or lambda
expressions.


Closures

• A function which includes a referencing environment


Closures

• Each function has its own scope
• Allows hiding state


Closures

• Each function has its own scope
• Allows hiding state
• Differentiating factor is that closures allow binding
references that exist at the time of creation, to use
when called.


Anonymous Functions

• Any function deﬁned and/or called without being
bound to an identiﬁer.
• You can assign the function to a variable, but
you’re not giving it its own name.


Functors

• Any object deﬁning a __invoke() method.
• Object instances can now be called as if they were
functions.

class Command
{
public function __invoke($name)
{
echo "Hello, $name";
}
}
$c = new Command();
$c(’Matthew’); // "Hello, Matthew"


Anonymous Functions

• new Closure class, which deﬁnes __invoke().


Anonymous Functions

• __invoke() body is “replaced” with the deﬁned
function.


Anonymous Functions

• __invoke() body is “replaced” with the deﬁned
function.
• Ability to bind variables via imports, allowing creation
of closures.


Important to know:

• Just like normal PHP functions, anonymous
functions exist in their own scope.


Important to know:

• You cannot import $this.


Important to know:

• You cannot import $this.
• You cannot alias imported variables.


Anonymous Function and
Closure Syntax

Basics

• Simply like normal function declaration, except no
name:

function($value1[, $value2[, ... $valueN]]) { };


Assign to variables

• Assign functions to variables; don’t forget the
semicolon terminator!

$greet = function($name) {
echo "Hello, $name";
};

$greet(’Matthew’); // "Hello, Matthew"


Pass as arguments to other callables

• Allow other functionality to call the function.

function say($value, $callback)
{
echo $callback($value);
}

say(’Matthew’, function($name) {
return "Hello, $name";
}); // "Hello, Matthew"


Create closures

• Bind variables at creation, and use them at call-time.

$log = Zend_Log::factory($config);

$logger = function() use($log) {
$args = func_get_args();
$log->info(json_encode($args));
};

$logger(’foo’, ’bar’); // ["foo", "bar"]


Array operations

• Sorting (usort, uasort, etc.)
• Walking, mapping, reducing
• Filtering


Sorting

$stuff = array(’apple’, ’Anise’, ’Applesauce’, ’appleseed’);
usort($stuff, function($a, $b) {
return strcasecmp($a, $b);
});
// ’Anise’, ’apple’, ’Applesauce’, ’appleseed’


Walking

• Walking allows you to change the values of an array.


Walking

• Walking allows you to change the values of an array.
• If not using objects, then you need to pass by
reference in order to alter values.

array_walk($stuff, function(&$value) {
$value = strtoupper($value);
});
// ’APPLE’, ’ANISE’, ’APPLESAUCE’, ’APPLESEED’


Mapping

• Mapping performs work on each element, resulting
in a new array with the values returned.


Mapping

• Mapping performs work on each element, resulting
in a new array with the values returned.

$mapped = array_map(function($value) {
$value = strtoupper($value);
return $value;
}, $stuff);
// $stuff: array(’apple’, ’Anise’, ’Applesauce’, ’appleseed’)
// $mapped: array(’APPLE’, ’ANISE’, ’APPLESAUCE’, ’APPLESEED’)


Reducing

• “Combine” elements and return a value or data set.


Reducing

• Return value is passed as ﬁrst argument of next call.


Reducing

• Return value is passed as ﬁrst argument of next call.
• Seed the return value by passing a third argument to
array_reduce().

$reduce = array_reduce($stuff, function($count, $input) {
$count += substr_count($input, ’a’);
return $count;
}, 0);
// $reduce: 3


Filtering

• Return only the elements that evaluate to true.


Filtering

• Return only the elements that evaluate to true.
• Often, this is a form of mapping, and used to trim a
dataset to only those of interest prior to reducing.

$reduce = array_reduce($stuff, function($count, $input) {
$count += substr_count($input, ’a’);
return $count;
}, 0);
// $reduce: 3


String operations

• Regular expressions (preg_replace_callback)


String operations

• Regular expressions (preg_replace_callback)
• Currying arguments


preg_replace_callback()

• Allows you to transform captured matches.

$string = "Today’s date next month is " . date(’Y-m-d’);
$fixed = preg_replace_callback(’/(d{4}-d{2}-d{2})/’,
function($matches) {
$date = new DateTime($matches[1]);
$date->add(new DateInterval(’P1M’));
return $date->format(’Y-m-d’);
}, $string);
// "Today’s date next month is 2011-05-26"


Currying arguments

• In some cases, you may want to provide default
arguments:


Currying arguments

arguments:
• To reduce the number of arguments needed.


Currying arguments

arguments:
• To supply values for optional arguments.


Currying arguments

arguments:
• To provide a uniﬁed signature for callbacks.


Currying arguments

arguments:
• To provide a uniﬁed signature for callbacks.

$hs = function ($value) {
return htmlspecialchars($value, ENT_QUOTES, "UTF-8", false);
};
$filtered = $hs("<span>Matthew Weier O’Phinney</span>");
// "<span>Matthew Weier O'Phinney</span>"


References

• Variables passed to callbacks, either as arguments
or imports, are not passed by reference.


References

• Use objects, or


References

• Use objects, or
• Pass by reference


References

• Use objects, or
• Pass by reference

$count = 0;
$counter = function (&$value) use (&$count) {
if (is_int($value)) {
$count += $value;
$value = 0;
}
};
$stuff = array(’foo’, 1, 3, ’bar’);
array_walk($stuff, $counter);
// $stuff: array(’foo’, 0, 0, ’bar’)
// $count: 4


Mixing with other callables

Problems and considerations:
• Closure is an “implementation detail”; typehinting
on it excludes other callback types.



• is_callable() tells us only that it can be called,
not how.



• is_callable() tells us only that it can be called,
not how.
• is_callable() && is_object() tells us we
have a functor, but omits other callback types.



Three ways to call (1/3):
• $o($arg1, $arg2)



• $o($arg1, $arg2)
• Beneﬁts: speed.



• $o($arg1, $arg2)
• Beneﬁts: speed.
• Problems: won’t work unless we have a functor,
closure, or static method call.



• call_user_func($o, $arg1, $arg2)



• Beneﬁts: speed, works with all callables.



• Beneﬁts: speed, works with all callables.
• Problems: if number of arguments are unknown
until runtime, this gets difﬁcult.



• call_user_func_array($o, $argv)



• Beneﬁts: works with all callables., works with
variable argument counts.



• Beneﬁts: works with all callables., works with
variable argument counts.
• Problems: speed (takes up to 6x longer to
execute than straight call).


You cannot import $this

• Creative developers will want to use closures to
monkey-patch objects.



• You can. You just can’t use $this, which means
you’re limited to public methods.



• You can. You just can’t use $this, which means
you’re limited to public methods.
• Also, you can’t auto-dereference closures assigned
to properties.


Example: Monkey-Patching

class Foo
{
public function __construct()
{
$self = $this;
$this->bar = function () use ($self) {
return get_object_vars($self);
};
}

public function addMethod($name, Closure $c)
{
$this->$name = $c;
}

public function __call($method, $args)
{
if (property_exists($this, $method) &&
is_callable($this->$method)) {
return call_user_func_array($this->$method, $args);
}
}
}


Serialization

• You can’t serialize anonymous functions.


Aspect Oriented Programming

• Code deﬁnes “aspects,” or code that cuts across
boundaries of many components.



• AOP formalizes a way to join aspects to other code.



• AOP formalizes a way to join aspects to other code.
• Often, you will need to curry arguments in order to
maintain signatures.


Event Management example

$front->events()->attach(’dispatch.router.post’, function($e) use
($cache) {
$request = $e->getParam(’request’);
if (!$request instanceof ZendHttpRequest || !$request->isGet())
{
return;
}

$metadata = json_encode($request->getMetadata());
$key = hash(’md5’, $metadata);
$backend = $cache->getCache(’default’);
if (false !== ($content = $backend->load($key))) {
$response = $e->getParam(’response’);
$response->setContent($content);
return $response;
}
return;
});


References

• PHP Manual:
http://php.net/functions.anonymous


Anonymous Functions in PHP 5.3 - Matthew Weier O’Phinney

More Related Content

What's hot (20)

Similar to Anonymous Functions in PHP 5.3 - Matthew Weier O’Phinney (20)

Recently uploaded (20)

Anonymous Functions in PHP 5.3 - Matthew Weier O’Phinney