PHP undtagelseshåndtering

Undtagelse (Exception) bruges til at ændre skriptets normale flow i bestemte fejl situationer.

Hvad er en undtagelse?

PHP 5 tilbyder en ny objektorienteret metode til fejlhåndtering.

Undtagelseshåndtering bruges til at ændre skriptets normale flow i bestemte fejl (undtagelser) situationer. Dette kaldes en undtagelse.

Når en undtagelse udløses, sker der normalt:

  • Den nuværende kodestatus gemmes
  • Kodeudførelsen skiftes til en prædefineret undtagelseshåndtererfunktion
  • Afhængigt af situationen kan håndtereren måske genstarte kodeudførelsen fra den gemte kodestatus, afslutte skriptet eller fortsætte skriptet fra en anden placering i koden

Vi vil vise forskellige fejlhåndteringsmetoder:

  • Undtagelsens grundlæggende brug
  • Opret en brugerdefineret undtagelseshåndterer
  • Flere undtagelser
  • Genkaste undtagelse
  • Sæt topundtagelseshåndterer

Undtagelsens grundlæggende brug

Når en undtagelse kastes, vil den efterfølgende kode ikke fortsætte med at køre, PHP vil forsøge at finde en matchende "catch"-blok.

Hvis undtagelsen ikke fanges, og der ikke bruges set_exception_handler() til passende håndtering, vil der opstå en alvorlig fejl (fatalt fejl) og outputtet "Uopfanget Exception" (ikke fanget undtagelse) fejlmelding.

Lad os forsøge at kaste en undtagelse, men ikke fange den:

<?php
//opret funktion med en undtagelse
function checkNum($number)
 {
 if($number>1)
  {
  throw new Exception("Værdien skal være 1 eller lavere");
  }
 return true;
 }
//udløs undtagelse
checkNum(2);
?>

Koden vil få en fejl som denne:

Fatalt fejl: Uopfanget undtagelse 'Exception' 
med besked 'Værdi skal være 1 eller lavere' i C:\webfolder\test.php:6 
Stakspor: #0 C:\webfolder\test.php(12): 
checkNum(28) #1 {main} kastet i C:\webfolder\test.php på linje 6

Try, throw og catch

For at undgå fejl som i ovenstående eksempel, skal vi oprette passende kode til at håndtere undtagelser.

Den korrekte håndteringsprogram skal inkludere:

  1. Forsøg - funktioner, der kaster undtagelser, skal placeres i en "try"-blok. Hvis ingen undtagelse udløses, vil koden fortsætte som normalt. Hvis en undtagelse udløses, vil der blive kastet en undtagelse.
  2. Throw - Her defineres, hvordan undtagelser udløses. Hver "throw" skal have mindst en modsvarende "catch"
  3. Catch - "catch"-blokken fanger undtagelsen og opretter et objekt med undtagelsesinformation

Lad os udløse en undtagelse:

<?php
//Opret en funktion, der kan kaste en undtagelse
function checkNum($number)
 {
 if($number>1)
  {
  throw new Exception("Værdien skal være 1 eller lavere");
  }
 return true;
 }
//Udløs undtagelse i "try"-blokken
try
 {
 checkNum(2);
 //Hvis undtagelsen kastes, vil denne tekst ikke blive vist
 echo 'Hvis du ser dette, er tallet 1 eller lavere';
 }
//Fang undtagelse
catch(Exception $e)
 {
 echo 'Besked: ' .$e->getMessage();
 }
?>

Denne kode vil få en fejl som denne:

Besked: Værdien skal være 1 eller lavere

Example explanation:

Denne kode kaster en undtagelse og fanger den:

  1. Opret checkNum() funktionen. Den tjekker om tallet er større end 1. Hvis det er tilfældet, kastes der en undtagelse.
  2. checkNum() funktionen kaldes i "try"-blokken.
  3. Undtagelsen i checkNum() funktionen kastes
  4. "catch"-blokken modtager denne undtagelse og opretter et objekt ($e) med undtagelsesinformation
  5. Ved at kalde $e->getMessage() fra denne exception objekt, outputtes fejlmeddelelsen fra undtagelsen

For at følge principet om, at hver "throw" skal have en modsvarende "catch", kan du indstille en topniveau undtagelseshåndterer til at håndtere manglende fejl.

Opret en brugerdefineret Exception klasse

Det er meget simpelt at oprette en brugerdefineret fejlhåndteringsprogram. Vi opretter simpelt en speciel klasse, som kan kalde sine funktioner, når der opstår en undtagelse i PHP. Denne klasse skal være en udvidelse af exception klassen.

Denne brugerdefinerede exception klasse arver alle egenskaber fra PHP's exception klasse, og du kan tilføje brugerdefinerede funktioner til den.

Vi starter med at oprette en exception klasse:

<?php
class customException extends Exception
 {
 public function errorMessage()
  {
  //error message
  $errorMsg = 'Fejl på linje '.$this->getLine().' i '.$this->getFile()
  : <b>'.$this->getMessage().'</b> er ikke en gyldig e-mailadresse
  return $errorMsg;
  }
 }
$email = "someone@example...com";
try
 {
 //Tjek om 
 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();
 }
?>

Denne nye klasse er en kopi af den gamle exception klasse, plus errorMessage() funktionen. På grund af, at det er en kopi af den gamle klasse, arver den egenskaber og metoder fra den gamle klasse, og vi kan bruge metoderne fra exception klassen, såsom getLine(), getFile() og getMessage().

Example explanation:

Ovenstående kode kaster en undtagelse og fanger den gennem en brugerdefineret exception klasse:

  1. The customException() class is created as an extension of the old exception class. This way, it inherits all properties and methods of the old class.
  2. Opret errorMessage() funktionen. Hvis e-mailadressen er ulovlig, returnerer denne funktion en fejlmeddelelse
  3. Sæt $email-variablen til en ulovlig e-mailadressestreng
  4. Udfør "try"-blokken, på grund af den ulovlige e-mailadresse, kastes der en undtagelse
  5. En "catch"-blok fanger undtagelsen og viser fejlmeddelelser

Flere undtagelser

Man kan bruge flere undtagelser til et script for at kontrollere flere situationer.

Man kan bruge flere if..else-blokker, eller en switch-blok, eller flere undtagelser indlejret. Disse undtagelser kan bruge forskellige exception-klasser og returnere forskellige fejlmeddelelser:

<?php
class customException extends Exception
{
public function errorMessage()
{
//error message
$errorMsg = 'Fejl på linje '.$this->getLine().' i '.$this->getFile()
: <b>'.$this->getMessage().'</b> er ikke en gyldig e-mailadresse
return $errorMsg;
}
}
$email = "someone@example.com";
try
 {
 //Tjek om 
 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 er en eksempel e-mail");
  }
 }
catch (customException $e)
 {
 echo $e->errorMessage();
 }
catch(Exception $e)
 {
 echo $e->getMessage();
 }
?>

Example explanation:

Ovenstående kode tester to betingelser, og hvis ingen af betingelserne er opfyldt, kastes der en undtagelse:

  1. The customException() class is created as an extension of the old exception class. This way, it inherits all properties and methods of the old class.
  2. Create the errorMessage() function. If the e-mail address is not valid, the function returns an error message.
  3. Udfør "try"-blokken, under den første betingelse, vil der ikke blive kastet en undtagelse.
  4. På grund af, at e-mail indeholder strengen "example", vil den anden betingelse udløse undtagelsen.
  5. En "catch"-blok fanger undtagelsen og viser passende fejlmeddelelser

Hvis customException ikke er fanget, men kun base exception, håndteres undtagelsen der.

Genkaste undtagelse

Ile af gangene, når en undtagelse kastes, ønsker du måske at håndtere den på en anden måde end standardmetoden. Det er muligt at kaste undtagelsen igen i en "catch"-blok.

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

<?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 e-mail address. If it is, the exception is thrown again:

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

Hvis en undtagelse ikke fanges i den nuværende "try"-blok, vil den søge efter en catch-blok på en højere niveau.

Indstil topniveau undtagelseshåndterer (Top Level Exception Handler)

set_exception_handler() funktionen kan indstille en brugerdefineret funktion til at håndtere alle ikke-fangede undtagelser.

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

Udskriften af ovenstående kode bør se sådan ud:

Exception: Uncaught Exception occurred

I ovenstående kode findes der ingen "catch"-blok, men en topniveau undtagelseshåndteringstriger aktiveres. Denne funktion bør bruges til at fange alle ikke-fangede undtagelser.

Undtagelsesregler

  • Kode, der skal håndtere undtagelser, skal placeres i en try-blok, så potentielle undtagelser kan fanges.
  • Hver try- eller throw-blok skal have mindst én tilsvarende catch-blok.
  • Flere catch-blokker kan bruges til at fange forskellige typer undtagelser.
  • En undtagelse kan kastes igen (re-thrown) i en catch-blok inden i en try-blok.

Kort sagt: Hvis en undtagelse kastes, skal den også fanges.