Page 1 of 4
PHP inner functions and the new anonymous functions are a little strange to say the least. However, just because something is strange doesn't mean that it isn't useful. We take a close look at the way PHP functions work.
PHP inner functions are very strange - they also happen to be very useful. In particular inner functions are very useful if you happen to be writing a Joomla extension.
Normally you will hear programmers familiar with other languages complaining about PHP's approach to inner functions. They often come to the conclusion that they are mostly a waste of time because they aren't local, they don't implement closure and they if the outer function is executed more than once they cause an error.
In fact as long as you understand how they work they can be very useful and without them your code could be very messy indeed.
When you put them together with anonymous functions, added in PHP 5.3.0, you have something that is almost, but not quite, the equal of what other languages offer. As PHP 5.3 isn't universally adopted first lets look at the situation before its arrival.
Functions are global
A PHP function is simple to define:
instructions that make up the function
You can include parameters and a return statement in general. The important point is that any function defined in this way has global scope. It can be called from anywhere within the entire program including from within another function and even from within a class or an instance of a class.
For example, if we define the function:
Then it can be used from within a class:
public function MyMethod()
and when the method is called
MyFunction is called.
This might seem perfectly normal to you as a PHP programmer but most other object oriented languages don't even allow you to define a function outside of a class, i.e. all functions are methods, so the idea of having global functions doesn't arise.
Using functions in this way is not a good idea even though it can be rationalised as providing "helper" functions to the objects you create. In general the functionality of a class should always be contained within the class and not made available by a global entity. You can argue that string functions are an example of utility functions that should be global, for example count_chars is a global function that returns the number of characters in a string, but is just an indication that you are not being object oriented enough. If a function does something to a string, i.e. it's a string operation, then it should be part of a string class.
To find any convincing examples of functions that should be global you have to look at either operations that involve more than one type - which class should the function belong to - or a where a single function works with multiple types. Working with multiple types is usually handled in fully object oriented languages by using generics but loosely typed languages such as PHP just allow you to ignore the problems of type and write a global function. It sort of works and avoids introducing a complicated idea into the language.
If you define a variable within a function it is local to that function. You can also define a function within another function and logically this too should be a local variable but recall the rule that all functions are global. In PHP inner functions are global and hence behave in the same way as if they had been declared outside of any containing function.
What this means is that inner functions are useless. As they are global they have the same context as a function declared in the usual way and this in turn means that they cannot support any of the clever tricks that other languages provide such as closure. Closure is where an inner function has access to the local variables of the function that contains it - even if the outer function no longer exists. As inner functions are global they have no privileged access to the local variables of the functions in which they are declared. Also as functions are global they never go out of scope and so are never destroyed.
Thus PHP functions miss two things that make closure possible and a useful feature and both are due to the the functions being global.
To be clear: an inner function behaves in exactly the same way as if it had been declared outside of its containing function. It has no access to the local variables of its containing function and concepts such as closure simply do not apply.