PHP Try Catch-voorbeeld: zelfstudie over uitzonderingen en foutafhandeling

Wat is een uitzondering?

Een fout is een onverwacht programmaresultaat dat niet door het programma zelf kan worden afgehandeld.

Fouten worden opgelost door het programma te repareren. Een voorbeeld van een fout is een oneindige lus die nooit stopt met uitvoeren.

Een uitzondering is een onverwacht programmaresultaat dat door het programma zelf kan worden afgehandeld.

Een voorbeeld van een uitzondering is het proberen een bestand te openen dat niet bestaat.

Deze uitzondering kan worden opgelost door het bestand aan te maken of door de gebruiker de mogelijkheid te bieden om naar het bestand te zoeken.

Waarom uitzonderingen afhandelen?

• Voorkom onverwachte resultaten op onze pagina's, die zeer vervelend of irritant kunnen zijn voor onze gebruikers.
• Verbeter de beveiliging van onze applicaties door geen informatie vrij te geven die kwaadwillende gebruikers kunnen gebruiken om onze applicaties aan te vallen
• PHP-uitzonderingen worden gebruikt om de normale programmastroom te wijzigen als er een voorspelbare fout optreedt.

PHP-foutafhandeling

Wanneer er een fout optreedt, afhankelijk van uw configuratie-instellingen, PHP geeft de foutmelding in de webbrowser weer met informatie over de opgetreden fout.

PHP biedt verschillende manieren om fouten af ​​te handelen. We gaan drie veelgebruikte methoden bekijken:

1. Die uitspraken De functie `die` combineert de functies `echo` en `exit` in één. Deze functie is erg handig wanneer we een bericht willen weergeven en de scriptuitvoering willen stoppen als er een fout optreedt.
2. Aangepaste foutafhandelaars – dit zijn door de gebruiker gedefinieerde functies die worden aangeroepen wanneer er een fout optreedt.
3. PHP-foutrapportage – Het foutbericht is afhankelijk van je PHP-foutrapportage-instellingen. Deze methode is erg handig in een ontwikkelomgeving wanneer je geen idee hebt wat de fout veroorzaakt. De weergegeven informatie kan je helpen bij het debuggen van je applicatie.

Voorbeelden van foutafhandeling

Laten we nu eens kijken naar enkele eenvoudige voorbeelden met foutafhandelingsroutines.

Stel dat we een berekening hebben waarbij een getal door nul gedeeld kan worden. We willen dat geval netjes afhandelen in plaats van dat PHP een foutmelding geeft.

De onderstaande code implementeert het bovenstaande voorbeeld.

<?php
$denominator = 0;
echo 2 / $denominator;
?>

Als je het bestand simple_error.php in de map phptuts hebt opgeslagen, open dan het bestand. URL http://localhost/phptuts/simple_error.php

U krijgt de volgende resultaten.

Zoals u uit de bovenstaande resultaten kunt zien, zorgt dit ervoor dat onze applicatie er onprofessioneel uitziet en vervelend kan zijn voor de gebruiker.

We zullen de bovenstaande code aanpassen en een foutafhandeling voor de applicatie schrijven.

<?php
$denominator = 0;
if ($denominator != 0) {
echo 2 / $denominator;
} else {
echo "cannot divide by zero (0)";
}
?>

Als je de bovenstaande code hebt opgeslagen als error_handling.php, open dan het bestand URL http://localhost/phptuts/error_handling.php

Let op: Het is een goede beveiligingspraktijk om een ​​bericht zoals hierboven weergegeven weer te geven in plaats van een onbewerkte melding zoals "Bestand niet gevonden".

Laten we eens kijken naar een ander voorbeeld waarin een aangepaste foutafhandelaar wordt gebruikt.

De aangepaste foutafhandelaar wordt ingesteld als de standaard PHP-foutafhandelingsfunctie en geeft in principe een foutnummer en bericht weer.

De onderstaande code illustreert de implementatie van het bovenstaande voorbeeld.

<?php
function my_error_handler($error_no, $error_msg)
{
echo "Oops, something went wrong:";
echo "Error number: [$error_no]";
echo "Error Description: [$error_msg]";
}
set_error_handler("my_error_handler");
echo (5 / 0);
?>

Open de URL http://localhost/phptuts/custom_error_handler.phpU krijgt de volgende resultaten.

Zoals je in het bovenstaande voorbeeld kunt zien, zijn aangepaste foutafhandelaars krachtig in de volgende zin:

• Ze stellen ons in staat de foutmeldingen aan te passen.
• De aangepaste foutafhandeling kan ook het vastleggen van fouten in een bestand of database, het versturen van een e-mail naar de ontwikkelaar en soortgelijke acties omvatten.

Laten we nu kijken naar het derde type foutafhandeling. We gaan hiervoor de ingebouwde PHP-functie `error_reporting` gebruiken. Deze heeft de volgende basissyntaxis.

<?php
error_reporting($reporting_level);
?>

HIER,

• “error_reporting” is de PHP-foutrapportagefunctie
• “$reporting_level” is optioneel en kan worden gebruikt om het rapportageniveau in te stellen. Als er geen rapportageniveau is opgegeven, gebruikt PHP het standaard foutrapportageniveau zoals gespecificeerd in het php.ini-bestand.

Verschil tussen fouten en uitzonderingen

• Uitzonderingen worden gegenereerd en zijn bedoeld om te worden opgevangen, terwijl fouten over het algemeen onherstelbaar zijn.
• Uitzonderingen worden objectgeoriënteerd afgehandeld. Dit betekent dat wanneer een uitzondering optreedt, er een uitzonderingsobject wordt aangemaakt dat de details van de uitzondering bevat.

De onderstaande tabel toont de methoden van het exception-object.

<?php
echo $e->getMessage();
?>

<?php
echo $e->getCode();
?>

<?php
echo $e->getFile();
?>

<?php
echo $e->getLine();
?>

<?php
print_r( $e->getTrace());
?>

<?php
echo $e->getPrevious();
?>

<?php
echo $e->getTraceAsString();
?>

<?php
echo $e->__toString();
?>

Hieronder vindt u de basis-syntaxis voor het genereren van een uitzondering.

<?php
throw new Exception("This is an exception example");
?>

HIER,

• 'gooien' is het sleutelwoord dat wordt gebruikt om de uitzondering te genereren
• “new Exception(…)” maakt een exception-object aan en geeft de tekenreeks “Dit is een voorbeeld van een uitzondering” door als berichtparameter.

De bovenstaande code genereert het volgende bericht.

We gaan nu kijken naar een voorbeeld waarin de `throw` en `catch` uitzonderingen worden geïmplementeerd. We zullen het bovenstaande voorbeeld aanpassen en `try`, `throw` en `catch` toevoegen.

De basissyntaxis is als volgt.

<?php
try {
// code goes here that could potentially throw an exception
}
catch (Exception $e) {
// exception handling code goes here
}
?>

HIER,

• “try{…}” is het codeblok dat moet worden uitgevoerd en dat mogelijk een uitzondering kan opleveren
• “catch(Exception $e){…}” is het codeblok dat de gegenereerde uitzondering opvangt en het uitzonderingsobject toewijst aan de variabele $e.

De onderstaande code toont een eenvoudig voorbeeld van een exception met `try`, `throw` en `catch`. Het programma gooit opzettelijk een exception, die het vervolgens opvangt.

<?php
try {
$var_msg = "This is an exception example";
throw new Exception($var_msg);
}
catch (Exception $e) {
echo "Message: " . $e->getMessage();
echo "";
echo "getCode(): " . $e->getCode();
echo "";
echo "__toString(): " . $e->__toString();
}
?>

Open de URL http://localhost/phptuts/exception_handling.phpU krijgt de volgende resultaten.

Het is ook mogelijk om meerdere uitzonderingen te creëren voor één PHP try-statement, afhankelijk van het type uitzondering dat wordt gegenereerd.

Zie het artikel op MySQLPHP-gegevenstoegang voor implementatievoorbeelden van meerdere uitzonderingen.

Meerdere uitzonderingen

Meerdere uitzonderingen maken gebruik van meerdere catch-blokken om de gegenereerde uitzonderingen af ​​te handelen. Meerdere uitzonderingen zijn nuttig wanneer:

• U wilt een aangepast bericht weergeven, afhankelijk van de gegenereerde uitzondering
• U wilt een unieke bewerking uitvoeren, afhankelijk van de uitzondering die is gegenereerd

Het onderstaande stroomdiagram illustreert hoe meerdere uitzonderingen werken.

Laten we eens kijken naar een voorbeeld met meerdere uitzonderingen. We zullen de code aanpassen die een getal deelt door de meegegeven noemer.

We verwachten dat er twee soorten uitzonderingen zullen optreden:

• Deling door nul
• Delen door een negatief getal

Om het eenvoudig te houden, zullen we in onze catch-blokken alleen het uitzonderingstype weergeven. De ingebouwde PHP-klasse `Exception` wordt gebruikt om uitzonderingen te gooien. We zullen twee klassen maken die de `Exception`-klasse uitbreiden en deze gebruiken om uitzonderingen te gooien.

Onderstaande code toont de implementatie.

<?php
class DivideByZeroException extends Exception {};
class DivideByNegativeException extends Exception {};
function process($denominator)
{
try
{
if ($denominator == 0)
{
throw new DivideByZeroException();
}
else if ($denominator < 0)
{
throw new DivideByNegativeException();
}
else
{
echo 25 / $denominator;
}
}
catch (DivideByZeroException $ex)
{
echo "DIVIDE BY ZERO EXCEPTION!";
}
catch (DivideByNegativeException $ex)
{
echo "DIVIDE BY NEGATIVE NUMBER EXCEPTION!";
}
catch (Exception $x)
{
echo "UNKNOWN EXCEPTION!";
}
}
process(0);
?>

Het testen van de code

We gaan ervan uit dat je multiple_exceptions.php in de phptuts-map hebt opgeslagen.

Blader naar het URL http://localhost/phptuts/multiple_exceptions.php

Ga terug naar het PHP-bestand en geef -1 op als parameter, zoals weergegeven in het volgende diagram.

Blader naar het URL http://localhost/phptuts/multiple_exceptions.phpWelke resultaten krijg je? Geef nu 3 als parameter door. Welke resultaten krijg je?

Het finally-blok en het PHP 7-foutmodel

Moderne PHP voegt twee belangrijke elementen toe aan het bovenstaande model. Het finally-blok wordt uitgevoerd na try en catch, ongeacht of er een uitzondering is opgetreden. Dit maakt het ideaal voor opruimacties zoals het sluiten van een bestand of een databaseverbinding.

Sinds PHP 7 worden veel voorheen fatale fouten als Error-objecten doorgegeven. Zowel Exception als Error implementeren de Throwable-interface, waardoor een catch (\Throwable $e)-blok beide kan afhandelen.

<?php
try {
$result = 10 / 0;
} catch (DivisionByZeroError $e) {
echo "Caught: " . $e->getMessage();
} finally {
echo "This message always runs";
}
?>

Hier geeft delen door nul een DivisionByZeroError in PHP 8. Het catch-blok meldt dit, en het finally-blok wordt altijd uitgevoerd en print zijn bericht, ongeacht of er een fout is opgetreden.

Veelgestelde vragen