finally

La parola chiave PHP "finally": una guida completa

La parola chiave finally fa parte della sintassi di gestione delle eccezioni di PHP. Un blocco finally è collegato a un'istruzione try ed è garantito che venga eseguito dopo il blocco try (e qualsiasi blocco catch corrispondente) — sia che il codice abbia avuto successo, abbia sollevato un'Exception o sia uscito anticipatamente. Questa garanzia lo rende il posto giusto per il lavoro di pulizia: chiusura di file, rilascio di lock, conclusione di transazioni su database o logging.

Questa pagina tratta la sintassi, l'ordine esatto in cui i blocchi vengono eseguiti, come finally interagisce con return e i pattern comuni in cui è realmente necessario.

Sintassi

Il blocco finally è collegato a un'istruzione try e viene eseguito dopo i blocchi try e qualsiasi blocco catch, indipendentemente dal fatto che sia stata sollevata o gestita un'eccezione. Ecco la sintassi di base per usare la parola chiave finally in PHP:

La sintassi PHP di finally

try {
  // code to be executed
} catch (Exception $e) {
  // code to handle the exception
} finally {
  // code to be executed regardless of whether an exception was thrown or caught
}

Il blocco catch è facoltativo quando è presente un blocco finally — try ... finally (senza catch) è PHP valido. In tal caso il blocco finally viene comunque eseguito, ma qualsiasi eccezione rimane non catturata e si propaga verso l'alto dopo che finally termina.

Come vengono eseguiti i blocchi

L'ordine è sempre lo stesso:

1. Viene eseguito il blocco try.
2. Se viene sollevata un'eccezione, viene eseguito il primo blocco catch corrispondente. Se nessuno corrisponde, l'eccezione viene trattenuta per essere rilanciata.
3. Viene eseguito il blocco finally — sempre.
4. Il controllo lascia l'istruzione (restituendo un valore o rilanciando un'eccezione non catturata).

Questo piccolo script rende visibile l'ordine:

<?php

function demo(bool $fail): void
{
  try {
    echo "1. try\n";
    if ($fail) {
      throw new Exception("boom");
    }
  } catch (Exception $e) {
    echo "2. catch: {$e->getMessage()}\n";
  } finally {
    echo "3. finally\n";
  }
  echo "4. after\n";
}

demo(false);
echo "---\n";
demo(true);

// Output:
// 1. try
// 3. finally
// 4. after
// ---
// 1. try
// 2. catch: boom
// 3. finally
// 4. after

Si noti che finally viene eseguito in entrambi i casi — una volta senza eccezione, una volta dopo il catch.

Esempi

Vediamo alcuni esempi pratici di come può essere utilizzata la parola chiave finally:

Esempi di PHP finally

<?php

// Example 1
function divide($a, $b)
{
  try {
    if ($b == 0) {
      throw new Exception("Division by zero.");
    }
    return $a / $b;
  } catch (Exception $e) {
    echo "Error: " . $e->getMessage();
  } finally {
    echo "This code will always be executed.";
  }
}

divide(10, 0);

// Output: Error: Division by zero.This code will always be executed.

// Example 2
$file = "example.txt";
$handle = fopen($file, "r");
try {
  if (!$handle) {
    throw new Exception("Unable to open file.");
  }
  // code to be executed
} catch (Exception $e) {
  echo "Error: " . $e->getMessage();
} finally {
  if ($handle !== false) {
    fclose($handle);
  }
}

// Output: Error: Unable to open file.

In questi esempi, utilizziamo la parola chiave finally per garantire che il codice di pulizia o logging venga eseguito in modo coerente.

finally e return

Un blocco finally viene eseguito anche quando try o catch contiene un return. PHP valuta il valore di ritorno, poi esegue finally, poi ritorna effettivamente. Se il blocco finally stesso restituisce un valore, quel valore sovrascrive quello precedente — una sottile fonte di bug, quindi evitare di restituire valori da finally.

<?php

function withReturn(): string
{
  try {
    return "from try";
  } finally {
    echo "finally still runs\n";
  }
}

function overriding(): string
{
  try {
    return "from try";
  } finally {
    return "from finally"; // overrides the try return
  }
}

echo withReturn() . "\n";
echo overriding() . "\n";

// Output:
// finally still runs
// from try
// from finally

La stessa regola di sovrascrittura si applica alle eccezioni: se finally solleva un'eccezione, questa sostituisce qualsiasi eccezione o valore di ritorno pendente da try/catch.

Vantaggi

L'utilizzo della parola chiave finally presenta diversi vantaggi, tra cui:

• Gestione degli errori migliorata: garantisce che il codice di pulizia o logging essenziale venga eseguito in modo coerente, anche quando si verificano o vengono gestite eccezioni.
• Codice semplificato: elimina la necessità di duplicare la logica di chiusura delle risorse in più blocchi catch o percorsi di errore.

Conclusione

In sintesi, la parola chiave finally fornisce un modo affidabile per eseguire il codice di pulizia essenziale durante la gestione delle eccezioni — chiusura di risorse, rilascio di lock e logging — indipendentemente dal fatto che sia stata sollevata un'eccezione. Utilizzarla ogni volta che una risorsa aperta in try deve essere rilasciata comunque, ed evitare di usare return in un blocco finally per non rischiare di perdere accidentalmente un risultato o un'eccezione.

Per approfondire la gestione degli errori PHP, vedere try, catch, la classe Exception e la guida generale alle eccezioni PHP.

Pratica