PHP-Exceptionen behandeln

Eine Ausnahme (Exception) wird verwendet, um den normalen Ablauf des Skripts bei bestimmten Fehlern zu ändern.

Was ist eine Ausnahme?

PHP 5 bietet eine neue objektorientierte Methode zur Fehlerbehandlung.

Ausnahmebehandlung wird verwendet, um den normalen Ablauf des Skripts bei bestimmten Fehlern (Ausnahmen) zu ändern. Dies wird als Ausnahme bezeichnet.

Wenn eine Ausnahme ausgelöst wird, tritt in der Regel folgendes auf:

  • Der aktuelle Codezustand wird gespeichert
  • Die Codeausführung wird auf eine vorgegebene Ausnahmebehandlungsfunktion umgeschaltet
  • Je nach Situation kann der Processor möglicherweise den Code von einem gespeicherten Codezustand neu starten, das Skript beenden oder das Skript von einem anderen Ort im Code fortsetzen

Wir werden verschiedene Fehlerbehandlungsmethoden demonstrieren:

  • Grundlegende Verwendung von Ausnahmen
  • Eigene Ausnahmebehandlungslogik erstellen
  • Mehrere Ausnahmen
  • Wiederherauswerfen von Ausnahmen
  • Oberste Ausnahmebehandlung festlegen

Grundlegende Verwendung von Ausnahmen

Wenn eine Ausnahme ausgelöst wird, wird der Code danach nicht fortgesetzt. PHP versucht, einen passenden "catch"-Codeblock zu finden.

Wenn die Ausnahme nicht gefangen wird und keine entsprechende Verarbeitung mit set_exception_handler() durchgeführt wird, tritt eine schwerwiegende Fehler (fatale Fehler) auf und die Fehlermeldung "Unbehandelte Ausnahme" wird ausgegeben.

Lassen Sie uns versuchen, eine Ausnahme auszulösen, ohne sie zu fangen:

<?php
// Funktion mit Ausnahme erstellen
function checkNum($number)
 {
 if($number>1)
  {
  throw new Exception("Wert muss 1 oder weniger sein");
  }
 return true;
 }
// Ausnahme auslösen
checkNum(2);
?>

Das obige Codebeispiel erhält eine Fehlermeldung wie diese:

Schwerer Fehler: Unbehandelte Ausnahme 'Exception' 
mit der Nachricht 'Wert muss 1 oder weniger sein' in C:\webfolder\test.php:6 
Stack trace: #0 C:\webfolder\test.php(12): 
checkNum(28) #1 {main} geworfen in C:\webfolder\test.php auf Zeile 6

Try, throw und catch

Um die in dem obigen Beispiel aufgetretenen Fehler zu vermeiden, müssen wir angemessenen Code schreiben, um Ausnahmen zu behandeln.

Die korrekte Verarbeitung sollte enthalten:

  1. Versuchen - Funktionen, die Ausnahmen verursachen, sollten im "try"-Codeblock liegen. Führt keine Ausnahme zu, so wird der Code wie gewohnt fortgesetzt. Wenn jedoch eine Ausnahme ausgelöst wird, wird eine Ausnahme geworfen.
  2. Throw - Hier wird geregelt, wie eine Ausnahme ausgelöst wird. Jeder "throw" muss mindestens einem "catch" entsprechen
  3. Catch - Der "catch"-Codeblock fängt die Ausnahme ab und erstellt ein Objekt, das Informationen über die Ausnahme enthält

Lassen Sie uns eine Ausnahme auslösen:

<?php
//Erstellen Sie eine Funktion, die eine Ausnahme auslösen kann
function checkNum($number)
 {
 if($number>1)
  {
  throw new Exception("Wert muss 1 oder weniger sein");
  }
 return true;
 }
//Ausnahme im "try"-Codeblock auslösen
try
 {
 checkNum(2);
 //Wenn die Ausnahme geworfen wird, wird dieser Text nicht angezeigt
 echo 'Wenn Sie dies sehen, ist die Zahl 1 oder weniger';
 }
//Ausnahme fangen
catch(Exception $e)
 {
 echo 'Nachricht: ' . $e->getMessage();
 }
?>

Das obige Code erhält eine ähnliche Fehlermeldung:

Nachricht: Wert muss 1 oder weniger sein

Example explanation:

Das obige Code zeichnet eine Ausnahme auf und fängt sie ab:

  1. Erstellen Sie die Funktion checkNum(). Sie überprüft, ob die Zahl größer als 1 ist. Wenn ja, wird eine Ausnahme geworfen.
  2. Die Funktion checkNum() wird im "try"-Codeblock aufgerufen.
  3. Die Ausnahme im checkNum()-Funktion wird geworfen
  4. "catch"-Codeblock empfängt diese Ausnahme und erstellt ein Objekt ($e), das Informationen über die Ausnahme enthält.
  5. Durch Aufruf von $e->getMessage() vom Exception-Objekt wird die Fehlermeldung der Ausnahme ausgegeben

Um der Regel "jeder throw muss ein catch haben" zu entsprechen, kann ein oberer Exception-Handler eingerichtet werden, um fehlende Fehler zu behandeln.

Erstellen Sie eine benutzerdefinierte Exception-Klasse

Die Erstellung eines benutzerdefinierten Exception-Handlers ist sehr einfach. Wir erstellen eine spezielle Klasse, deren Funktionen aufgerufen werden können, wenn eine Ausnahme in PHP auftritt. Diese Klasse muss eine Erweiterung der Exception-Klasse sein.

Diese benutzerdefinierte Exception-Klasse erbt alle Eigenschaften der PHP-Exception-Klasse und Sie können eigene Funktionen hinzufügen.

Wir beginnen mit der Erstellung der Exception-Klasse:

<?php
class customException extends Exception
 {
 public function errorMessage()
  {
  //error message
  $errorMsg = 'Fehler auf Zeile '.$this->getLine().' in '.$this->getFile()
  : <b>'.$this->getMessage().'</b> ist keine gültige E-Mail-Adresse
  return $errorMsg;
  }
 }
$email = "someone@example...com";
try
 {
 // Überprüfen Sie, ob 
 if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE)
  {
  //throw exception if email is not valid
  throw new customException($email);
  }
 }
catch (customException $e)
 {
 //display custom message
 echo $e->errorMessage();
 }
?>

Diese neue Klasse ist eine Kopie der alten Exception-Klasse, ergänzt durch die Funktion errorMessage(). Da es sich um eine Kopie der alten Klasse handelt, erbt sie Attribute und Methoden von der alten Klasse. Wir können Methoden der Exception-Klasse wie getLine(), getFile() und getMessage() verwenden.

Example explanation:

Der obige Code wirft eine Ausnahme aus und fängt sie durch eine benutzerdefinierte Exception-Klasse ab:

  1. The customException() class was created as an extension of the old exception class. This means it inherits all properties and methods of the old class.
  2. Erstelle die Funktion errorMessage(). Wenn die E-Mail-Adresse ungültig ist, gibt diese Funktion eine Fehlermeldung zurück
  3. Setze die Variable $email auf einen ungültigen String einer E-Mail-Adresse
  4. Führe den "try"-Codeblock aus. Da die E-Mail-Adresse ungültig ist, wird eine Ausnahme ausgelöst
  5. Ein "catch"-Codeblock fängt Ausnahmen ab und zeigt eine Fehlermeldung an

Mehrere Ausnahmen

Man kann für ein Skript mehrere Ausnahmen verwenden, um verschiedene Szenarien zu überprüfen.

Man kann mehrere "if..else"-Codeblöcke oder einen "switch"-Codeblock verwenden oder mehrere Ausnahmen verschachteln. Diese Ausnahmen können mit verschiedenen Exception-Klassen verwendet werden und unterschiedliche Fehlermeldungen zurückgeben:

<?php
class customException extends Exception
{
public function errorMessage()
{
//error message
$errorMsg = 'Fehler auf Zeile '.$this->getLine().' in '.$this->getFile()
: <b>'.$this->getMessage().'</b> ist keine gültige E-Mail-Adresse
return $errorMsg;
}
}
$email = "someone@example.com";
try
 {
 // Überprüfen Sie, ob 
 if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE)
  {
  //throw exception if email is not valid
  throw new customException($email);
  }
 //check for "example" in mail address
 if(strpos($email, "example") !== FALSE)
  {
  throw new Exception("$email ist eine Beispiel-E-Mail");
  }
 }
catch (customException $e)
 {
 echo $e->errorMessage();
 }
catch(Exception $e)
 {
 echo $e->getMessage();
 }
?>

Example explanation:

Der obige Code testet zwei Bedingungen. Wird keine Bedingung erfüllt, wird eine Ausnahme ausgelöst:

  1. The customException() class was created as an extension of the old exception class. This means it inherits all properties and methods of the old class.
  2. The errorMessage() function was created. If the email address is not valid, this function returns an error message.
  3. Führe den "try"-Codeblock aus. Unter der ersten Bedingung wird keine Ausnahme ausgelöst.
  4. Da der E-Mail-Text den String "example" enthält, wird die zweite Bedingung eine Ausnahme auslösen.
  5. Ein "catch"-Codeblock fängt Ausnahmen ab und zeigt eine angemessene Fehlermeldung an

Wenn "customException" nicht erfasst wurde und nur "base exception" erfasst wurde, wird die Ausnahme dort behandelt.

Wiederherauswerfen von Ausnahmen

Manchmal, wenn ein Ausnahmevorfall auftritt, möchten Sie möglicherweise anders als standardmäßig damit umgehen. Eine Ausnahme kann in einem "catch"-Codeblock erneut ausgelöst werden.

The script should hide system errors from the user. While system errors may be important to programmers, users are not interested in them. To make it easier for users, you can throw exceptions with user-friendly messages again:

<?php
class customException extends Exception
 {
 public function errorMessage()
  {
  //error message
  $errorMsg = $this->getMessage().' is not a valid E-Mail address.';
  return $errorMsg;
  }
 }
$email = "someone@example.com";
try
 {
 try
  {
  //check for "example" in mail address
  if(strpos($email, "example") !== FALSE)
   {
   //throw exception if email is not valid
   throw new Exception($email);
   }
  }
 catch(Exception $e)
  {
  //re-throw exception
  throw new customException($email);
  }
 }
catch (customException $e)
 {
 //display custom message
 echo $e->errorMessage();
 }
?>

Example explanation:

The above code checks if the string "example" is present in the email address. If it is, the exception is thrown again:

  1. The customException() class was created as an extension of the old exception class. This means it inherits all properties and methods of the old class.
  2. The errorMessage() function was created. If the email address is not valid, this function returns an error message.
  3. The $email variable was set to a valid email address, but it contains the string "example".
  4. The "try" code block contains another "try" code block, allowing the exception to be thrown again.
  5. An exception was triggered because the e-mail contains the string "example".
  6. "catch" caught the exception and re-threw "customException".
  7. A "customException" was caught and an error message was displayed.

Wenn eine Ausnahme in ihrem aktuellen "try"-Codeblock nicht gefangen wird, sucht sie auf höherer Ebene nach einem catch-Codeblock.

Top-Level-Ausnahmebehandlungsmechanismus einrichten

Die Funktion set_exception_handler() kann eine benutzerdefinierte Funktion zur Verarbeitung aller nicht erfassten Ausnahmen festlegen.

<?php
function myException($exception)
{
echo "<b>Exception:</b> " , $exception->getMessage();
}
set_exception_handler('myException');
throw new Exception('Unbekannte Ausnahme aufgetreten');
?>

Die Ausgabe des obigen Codes sollte ähnlich aussehen:

Exception: Unbekannte Ausnahme aufgetreten

Im obigen Code gibt es keinen "catch"-Codeblock, sondern wird den obersten Ausnahmebehandlungsmechanismus ausgelöst. Diese Funktion sollte verwendet werden, um alle nicht erfassten Ausnahmen zu fangen.

Regeln für Ausnahmen

  • Der Code, der Ausnahmen verarbeiten muss, sollte in einem try-Codeblock platziert werden, um potenzielle Ausnahmen zu erfassen.
  • Jeder try- oder throw-Codeblock muss mindestens einen entsprechenden catch-Codeblock haben.
  • Mit mehreren catch-Codeblocks können verschiedene Arten von Ausnahmen erfasst werden.
  • Es ist möglich, eine Ausnahme im catch-Codeblock innerhalb eines try-Codeblocks erneut auszulösen (wiederholt).

Kurz gesagt: Wenn eine Ausnahme ausgelöst wird, muss sie gefangen werden.