PHP Inner Functions And Closure
Written by Alex Armstrong   
Wednesday, 22 April 2015
Article Index
PHP Inner Functions And Closure
Object-oriented PHP
Closure

PHP inner functions and 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 and how you might be writing one even if you don't know you are...

 

Banner

 

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.

But first let's look at the basics of PHP functions. 

Functions are global

A PHP function is simple to define:

function MyFunction()
{
 instructions that make up the function
}

You can include parameters and a return statement.

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:

function MyFunction()
{
 echo("My Function");
}

Then it can be used from within a class:

class MyClass
{
 public function MyMethod()
 {
  MyFunction();
 }
}

and when the method is called

$MyObject=new MyClass();
$MyObject->MyMethod();

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.

Inner functions

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.

 

Banner

 

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. 

Lifetimes

The fact that functions are global means that they don't go out of scope which means that they are never destroyed.

But this doesn't mean that every function has the same lifetime as the program they are contained in.

Any function that you simply declare as part of the program's text can be considered to exist as soon as the program starts running and exist until the program comes to an end. However, PHP is a dynamic interpreted language and this means that it can do things with its own text that other languages can't.

For example you can conditionally declare a function:

if($test) {
 function MyFunction()
 {
  echo("My Function");
 }
}

 

This results in MyFunction not existing within the program until the if statement is executed and the condition is true. Once this has happened the function exists and continues to exist until the end of the program.

You can think of this as

"the function exists from the moment that PHP gets to read about it".

This is a completely general mechanism and applies to any declaration of a function within other PHP code.

Notice that as a function cannot be redefined within PHP this means that any code that declares a function can only be executed once - or you have to make sure that the logic is such that the function isn't created a second time. 

It also applies to inner functions and this means that an inner function doesn't exist until the outer function has been called. This some how seems much stranger than the conditional example given earlier but it really is just the same principle at work.

For example, if you define two functions, one within the other:

function MyFunction()
{
 echo("My Function");
 function MyInnerFunction()
 {
   echo('MyInnerFunction ');
 }
}

Then if you simply call MyInnerFunction() it will fail. To make it work you first have to call the outer function and only then does the inner function exist. That is:

MyFunction();
MyInnerFunction();

works but after calling MyFunction once you can't call it again without generating an error.

The solution to the problem of trying to create a function more than once is to make use of the conditional declaration idea. For example:

function MyFunction()
{
 echo("My Function");
 if(!function_exists("MyInnerFunction")){
  function MyInnerFunction()
  {
   echo('MyInnerFunction ');
  }
 }
}

The way that this works should now be obvious. The if statement simply checks to see if the function name exists in the global scope. If it does then the function isn't declared a second time and no error occurs.

You should always enclose inner function declarations within if statements - it makes them safer and it costs very little.

Now we come to a subtle point but one that turns out to have practical import.

Can you call an inner function from within the function that encloses it?

The answer is yes but only after it has been defined. For example; you can't use

function MyFunction()
{
 echo("My Function");
 MyInnerFunction();
 if(!function_exists("MyInnerFunction")){
   function MyInnerFunction()
   {
    echo('MyInnerFunction ');
   }
 }
}

 

Banner

 

The problem is that when you try to call MyInnerFunction it hasn't been declared yet. However if you move the call to after the if then everything is fine:

function MyFunction()
{
 echo("My Function");
 if(!function_exists("MyInnerFunction")){
   function MyInnerFunction()
   {
    echo('MyInnerFunction ');
   }
 }
 MyInnerFunction();
}

 

This is strange and takes some time to get used to but it is perfectly logical.

Of course the second time MyFunction is called the inner function is already defined and you could in principle call the inner function anywhere you like - as the inner function is global really anywhere you like!

<ASIN:0596006306>

<ASIN:0596101015>

<ASIN:0321442490>

<ASIN:0596005601>

<ASIN:0672329166>

<ASIN:1590598628>



Last Updated ( Wednesday, 22 April 2015 )
 
 

   
RSS feed of all content
I Programmer - full contents
Copyright © 2015 i-programmer.info. All Rights Reserved.
Joomla! is Free Software released under the GNU/GPL License.