What is Finally for in PHP 5.5?

Question

PHP 5.5 implemented a feature (which I’ve heard exists in other languages) called finally, in the handling of exceptions (together with the try/catch)

We have the following example:

set_error_handler(function ($errno, $errstr, $errfile, $errline ) {

    throw new ErrorException($errstr, 0, $errno, $errfile, $errline); 

});

try{

    $b = (new stdClass)->non_exists; // gera um erro de propósito

} catch(Exception $e) {

 echo  $e->getMessage(), PHP_EOL; // imprime a mensagem da captura da exceção

} finally {

   echo 'acabou!'; // imprime "acabou" (indepentende de entrar no catch ou não
}

In practice, how could it be useful to use the finally? (because I don’t understand why he runs even when he doesn’t fall in catch)

Answer 1

Essentially it is to ensure that the flow of that block always runs. Even if an exception occurs in the block started by try, the block of finally will run before exiting the function and start to knock down the function call stack.

In general it is used to terminate allocated resources, for example close a file.

There may arise a doubt as to what is the difference to the catch which is also executed when there is an exception. The difference is that the catch is only executed when there is an exception. The finally is executed with or without exception. The execution flow of the program goes from try to the finally always, be why the try closed normally, either because it generated an exception. The catch is a conditional execution block (by launching an exception), the finally is enforceable.

Remembering that the release of an exception will force the execution of both the catch, how much of finally, but any code that comes after this whole block try-catch-finally nothing will be executed.

Perhaps you give an impression of little use of it because of examples that do nothing useful effectively.

Documentation.

Good generic example:

    $recurso = abrir_recurso();
    try {
        $resultado = use_rercurso($rercurso);
    } finally {
        libere_rercurso($rercurso); //acontecendo ou não uma exceção, o recurso será fechado
    }
    return $resultado;

Actual example taken from that blog:

function addRecord($record, $db) {
    try {
      $db->lock($record->table);
      $db->prepare($record->sql);
      $db->exec($record->params);
    } catch(Exception $e) {
        $db->rollback($record);
        if (!write_log($e->getMessage(), $e->getTraceAsString())) {
            throw new Exception('Unable to write to error log.');
        }
    } finally {
        $db->unlock($record->table);
    }
    return true;
}

I put in the Github for future reference.

The example is bad because it captures Exception and launches again but the general idea is this.

Reading suggestion. It’s not the same language but it works the same way.

Answer 2

Try => It is the command block that you want to run

Catch = > This is the command block you run if an error occurs (Exception). You Can Treat Multiple exceptions. Catch will only be executed when an exception occurs.

Finally = > Like catch is the block that runs only when an exception occurs, the block finally will always run, regardless of error. A good use of finally is close connection to the database.