Flos Buzzword-Bingo

Seit PHP 5.2 gibt es nicht nur die Möglichkeit, mittels try and catch nicht nur Code zu umschachteln, sondern auch wirklich Fehler zu fangen. Immer wieder findet man Codebeispiele, die die nicht-typisierte Eigenschaft von PHP gnadenlos ausnutzen und anstatt des erwarteten Datentyps einen Fehler aus einer Funktion zurück gibt.

In typisierten, höheren Programmiersprachen ist die natürlich nicht möglich. Das heißt aber nicht, dass man an jede Funktion einen referenziellen Parameter anfügt, mit dem man eventuelle Fehler auslesen kann. Das magische Stichwort heißt deshalb: Fehlerbehandlung mittels Exception-Behandlung.

Um Fehler ordnungsgemäß zu behandeln, kann man sich in PHP dem dem Fehlerabfang und -werfkonstruktes bedienen. Dazu sollte man sich zu erst Ableitungen der Klasse Exception erstellen:

class FSException extends Exception
{
  /**
   * Vorher gefangene Exception
   *
   * @var Exception
   */
  protected $objInnerException = null;
  protected $intType = self::HINWEIS;
 
  const HINWEIS = 0;
  const FEHLER = 1;
  const SCHWERER_FEHLER = 2;
 
  public function __construct($intCode, $strText,
    $intType = self::FEHLER, $objInnerException = null)
  {
    $this->objInnerException = $objInnerException;
    $this->intType = $intType
    parent::__construct($strText, $intCode);
  }
 
  public function __toString()
  {
    return "Hier kann man alle gesammelten Exceptions ausgeben.";
  }
}
 
final class FSDatenbankException extends FSException
{
  private $intSqlErrorCode = 0;
  private $strSqlErrorText = "";
 
  public function __construct($intSqlCode, $strSqlText, $intCode,
    $strText, $intType = self::FEHLER, $objInnerException = null)
  {
    $this->intSqlErrorCode = $intSqlCode;
    $this->strSqlErrorText = $strSqlText;
    parent::__construct($intCode, $strText, $intType,
      $objInnerException);
  }
 
  public function getErrorText()
  {
    return $this->getMessage();
  }
}
 

Die eigenen Klassen haben zwei große Vorteile: Jede Instanz kann die vorher gefangene Exception halten, sodass sich ein Pfad vom Ursprung des Fehlers bis hin auf die höchste Ebene nachverfolgen läßt, der bei der Fehlersuche und -behebung einen ungemeinen Vorteil bringt.
Des weiteren kann man mit Hilfe des Fehlertypes sein weiteres Programm steuern. So kann man beim Fangen der Fehler explizit auf den Fehlertyp achten und zum Beispiel bei Hinweisen nur Texte ausgeben, bei Fehlern dem entsprechend anders reagieren.

Das folgende Beispiel soll die Fehlerbehandlung besser visualisieren:

class TestDatenbank
{
  /**
   * Holt Daten und gibt diese in einem Array zurück
   *
   * Holt Daten aus der Datenbank und liefert ein Array und ...
   *
   * @param int $intId Text Id
   * @return array
   * @throws FSException
   */
  public function holeDaten($intId)
  {
    try
    {
      if (is_numeric($intId))
      {
        try
        {
          if ($objResult = $this->holeDaten())
          {
            /* ... */
          }
          else throw new FSException(mysql_errno(), mysql_error(),
            123, "Keine Daten");
        }
        catch (FSException $objException)
        {
          throw new FSException(10000, "Fehler beim Holen",
            FSException::FEHLER, $objException);
        }
        catch (Exception $objException)
        {
          throw new FSException(10000, "Schwerer Fehler beim Daten-
            holen", sFSException::SCHWERER_FEHLER, $objException);
        }
      }
      else throw new FSException(1000, "holeDaten-Aufruf doof!");
    }
    catch (FSException $objException)
    {
      throw new FSException(10000, "Fehler in TestDB->holeDaten",
        FSException::FEHLER, $objException);
    }
    catch (Exception $objException)
    {
      throw new FSException(10000, "Schwerer Fehler in TestDB->
        holeDaten", sFSException::SCHWERER_FEHLER, $objException);
    }
  }
}
 
try
{
  $objDatenbank = new TestDatenbank();
  $objDatenbank->holeDaten(1);
}
catch (FSException $objException)
{
  /* Fehler ausgeben und loggen */
}
catch (Exception $objException)
{
  /* Fehler ausgeben, loggen, Mail an Admin */
}
 

Hierbei ist es wichtig darauf zu achten, dass man die abgeleiteten Exceptions zuerst fängt, da eine abgeleitete Exception auch mittel catch (Exception $objException) gefangen werden können.

Mit diesem Konstrukten wird eine reibungslose Abwicklung des Codes auch bei Fehlern gewährt und es nie wieder Fehler geben, die bis zum Benutzer vordringen. Mit beliebigen Ableitungen und einer Exception-Trace-Visualisierungsklasse kann man im Debugmodus perfekt Fehlerbäume bauen, die einem bequemen Debuggen sehr nahe kommen.

C# und Java-Entwickler werden diese Dinge kennen...

In Kombination mit PHPDoc und sensitiver Codevervollständigung kann mein seinen PHP-Code näher an der Perfektion bringen:

Und mal ehrlich, wer will denn sowas?

/**
 * Ich soll einen Sting liefern, bin kann aber auch
 * ein Boolean liefern. Dann aber mit Error array...
 *
 * @param int $intId Irgendeine ID
 * @param array $arrError Error array
 * @return string ODER false???
 */
function test($intId, &$arrError)
{
  if ($intId)
  {
    return "string";
  }
  else
  {
    $arrError["code"] = 123;
    return false;
  }
}