The newest PHP version is almost ready. At the time I’m writing this blog PHP 5.5 is in RC 1.

As I was saying in my last blog, the feature list is available at: http://www.php.net/manual/en/migration55.new-features.php

The second feature, in terms of popularity, is “finally“: http://www.php.net/manual/en/language.exceptions.php

What’s the deal with “finally“?

It looks a little confusing, is looks like a block that’s getting executed after the “try/catch” finishes. But what is so new about it?

Let’s take a try/catch block:

PHP 5.x < 5.5:

 1// open resouce
 2$resource = new Resouce();
 3try {
 4   // do stuff with the resouce
 5   $resouce->doStuff();
 6} catch (Exception $e) {
 7   // log exception
 8   syslog(LOG_ERR, $e->getMessage());
 9}
10// release resouce
11unset($resouce);

PHP 5.5

 1// open resouce
 2$resource = new Resouce();
 3try {
 4   // do stuff with the resouce
 5   $resouce->doStuff();
 6} catch (Exception $e) {
 7   // log exception
 8   syslog(LOG_ERR, $e->getMessage());
 9} finally {
10   // release resouce
11   unset($resouce);
12}

Up to this point there isn’t any reason for a new block. The exception was catched, it was logged and continues.

But let’s say there is a resource and we need to close it, and after that we need to throw an exception. One way this can be achieved is to release the resource in catch.

But there is still the “successful” case, and we need to release it in that case also.

 1// open resouce
 2$resource = new Resouce();
 3try {
 4   // do stuff with the resouce
 5   $resouce->doStuff();
 6} catch (Exception $e) {
 7   // release resouce
 8   unset($resource);
 9   // perpetuate exception
10   throw $e;
11}

Let’s complicate stuff even more, let’s say there are n exception types. It will result in n catch conditions, plus the successful case, and in all of these cases we need to free the resource. Not very efficient…

Another way is to store the exception in a variable and, after the resource is released, to throw the exception, if that is the case.

 1// variable to store the exception
 2$exception = false;
 3
 4// open resouce
 5$resource = new Resouce();
 6try {
 7   // do stuff with the resouce
 8   $resouce->doStuff();
 9} catch (Exception $e) {
10   $exception = $e;
11}
12
13// release resouce
14unset($resource);
15
16if($exception) {
17   throw $exception;
18}

This is one way it is done right now. It’s working but it’s not clear that we are only trying to release the resource and continue our lives in peace.

The PHP 5.5 way

In the php.net manual:

In PHP 5.5 and later, a finally block may also be specified after the catch blocks. Code within the finally block will always be executed after the tryand catch blocks, regardless of whether an exception has been thrown, and before normal execution resumes.

Each time the block is executed, regardless if it was successful or not, finally will get executed. So, for the next example:

1try {
2    echo 'Do stuff' . PHP_EOL;
3    throw new Exception('testing');
4} finally {
5    echo 'inside finally' . PHP_EOL;
6}

The output will be:

1Do stuff
2inside finally
3
4Fatal error: Uncaught exception 'Exception' with message 'testing' in...

If we want to also catch the exception:

1try {
2    echo 'Do stuff' . PHP_EOL;
3    throw new Exception('testing');
4} catch (Exception $e) {
5    echo 'do something with the exception' . PHP_EOL;
6} finally {
7    echo 'inside finally' . PHP_EOL;
8}

The output will be:

1Do stuff
2do something with the exception
3inside finally

And even if we take the particular case when we catch the exception and then throw it:

1try {
2    echo 'Do stuff' . PHP_EOL;
3    throw new Exception('testing');
4} catch (Exception $e) {
5    echo 'do something with the exception' . PHP_EOL;
6    throw $e;
7} finally {
8    echo 'inside finally' . PHP_EOL;
9}

It seems we prevented the finally block from getting executed? Well, not exactly…

1Do stuff
2do something with the exception
3inside finally
4
5Fatal error: Uncaught exception 'Exception' with message 'testing' in...

In other words, the finally block gets executed each time, regardless of the result.