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 zijn onverwachte programmaresultaten die door het programma zelf kunnen worden afgehandeld.

Voorbeelden van uitzonderingen zijn onder meer 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 omgaan met uitzonderingen?

• Vermijd onverwachte resultaten op onze pagina's die erg vervelend of irriterend kunnen zijn voor onze eindgebruikers
• 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 stroom van een programma 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 een aantal manieren om met fouten om te gaan.

We gaan kijken naar drie (3) veelgebruikte methoden;

1. Die uitspraken– de die-functie combineert de echo- en exit-functie in één. Het is erg handig als we een bericht willen uitvoeren en de uitvoering van het script 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 – de foutmelding is afhankelijk van uw PHP-foutrapportage-instellingen. Deze methode is erg handig in een ontwikkelomgeving wanneer u geen idee hebt wat de fout heeft veroorzaakt. De weergegeven informatie kan u helpen bij het debuggen van uw applicatie.

Voorbeelden van foutafhandeling

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

Laten we aannemen dat we een applicatie hebben ontwikkeld die tekstbestanden gebruikt om gegevens op te slaan. Mogelijk willen we controleren of het bestand bestaat voordat we proberen er gegevens uit te lezen.

De onderstaande code implementeert het bovenstaande voorbeeld.

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

Ervan uitgaande dat u het bestand simple_error.php in de map phptuts hebt opgeslagen, opent u de 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 foutafhandelaar voor de applicatie schrijven

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

Ervan uitgaande dat u de bovenstaande code hebt opgeslagen als error_handling.php, opent u de URL http://localhost/phptuts/error_handling.php

Opmerking: Het is een goede beveiligingspraktijk om een ​​bericht weer te geven zoals hierboven weergegeven in plaats van een bericht als "Bestand niet gevonden".

Laten we eens kijken naar een ander voorbeeld waarin een aangepaste fouthandler 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 "Opps, 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.php je krijgt de volgende resultaten

.

• Ze stellen ons in staat de foutmeldingen aan te passen.
• De aangepaste foutafhandeling kan ook foutregistratie in een bestand/database, e-mails naar de ontwikkelaar, etc. omvatten.

Laten we nu eens kijken naar het derde type foutbehandeling. We gebruiken de ingebouwde PHP-functie error_reporting function. 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 op een objectgeoriënteerde manier verwerkt. Dat wil zeggen dat wanneer er een uitzondering optreedt, er een uitzonderingsobject wordt gemaakt met de details van de uitzondering.

De onderstaande tabel toont de uitzonderingsobjectmethoden

<?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();
?>

<?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 uitzonderingsobject en geeft de tekenreeks “Dit is een voorbeeld van een uitzondering” door als de berichtparameter.

De bovenstaande code genereert het volgende bericht.

We gaan nu kijken naar een voorbeeld waarin de uitzonderingen voor gooien en vangen worden geïmplementeerd.

We zullen het bovenstaande voorbeeld aanpassen en de try, throw en catch erin opnemen.

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 het basisvoorbeeld van een uitzondering, waarbij de uitzondering try, throw en catch is geïmplementeerd.

Het programma genereert opzettelijk een uitzondering die vervolgens wordt opgevangen.

<?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.php U krijgt de volgende resultaten.

Het is ook mogelijk om meerdere uitzonderingen te maken voor één php try-instructie, afhankelijk van het type uitzondering dat wordt gegenereerd.

Zie het artikel op MySQL, PHP-gegevenstoegang… voor implementatievoorbeelden van meerdere uitzonderingen

Meerdere uitzonderingen

Meerdere uitzonderingen gebruiken meerdere try-catch-blokken om de gegenereerde uitzonderingen af ​​te handelen. Meerdere uitzonderingen zijn handig 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 waarin meerdere uitzonderingen worden gebruikt.

We zullen de code wijzigen die een getal deelt door de doorgegeven noemer.

We verwachten dat er twee soorten uitzonderingen zullen optreden;

• Deling door nul
• Delen door een negatief getal

Voor de eenvoud zullen we alleen het uitzonderingstype weergeven in onze catch-blokken.

De in PHP ingebouwde Exception-klasse wordt gebruikt om uitzonderingen te genereren.

We zullen twee klassen maken die de uitzonderingsklasse uitbreiden en deze gebruiken om uitzonderingen te genereren.

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 map phptuts hebt opgeslagen.

Blader naar de 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 de URL http://localhost/phptuts/multiple_exceptions.php.

Welke resultaten krijg je? Geef 3 door als parameter.

Welke resultaten krijg je?

Samenvatting

• Fouten zijn onverwachte resultaten die door PHP-code worden geproduceerd
• Foutafhandeling verbetert de prestaties van de applicatie
• PHP heeft ingebouwde functies die kunnen worden gebruikt om de manier aan te passen waarop PHP fouten rapporteert
• Uitzonderingen zijn net als fouten, maar ze kunnen worden opgevangen met behulp van het vangblok wanneer ze worden gegooid.
• Het weergeven van foutmeldingen met foutinformatie wordt als een slechte beveiligingspraktijk beschouwd.