PHP Try Catch Exempel: Handledning för undantag och felhantering

Vad är ett undantag?

Ett fel är ett oväntat programresultat som inte kan hanteras av själva programmet.

Fel åtgärdas genom att åtgärda programmet. Ett exempel på ett fel skulle vara en oändlig loop som aldrig slutar exekvera.

Ett undantag är oväntade programresultat som kan hanteras av själva programmet.

Exempel på undantag är att försöka öppna en fil som inte finns.

Detta undantag kan hanteras genom att antingen skapa filen eller ge användaren möjlighet att söka efter filen.

Varför hantera undantag?

• Undvik oväntade resultat på våra sidor som kan vara mycket irriterande eller irriterande för våra slutanvändare
• Förbättra säkerheten för våra applikationer genom att inte avslöja information som skadliga användare kan använda för att attackera våra applikationer
• Php-undantag används för att ändra det normala flödet av ett program om något förutsägbart fel inträffar.

PHP Felhantering

När ett fel uppstår, beroende på dina konfigurationsinställningar, PHP visar felmeddelandet i webbläsaren med information om felet som uppstod.

PHP erbjuder ett antal sätt att hantera fel.

Vi kommer att titta på tre (3) vanliga metoder;

1. Dö uttalanden– stansfunktionen kombinerar eko- och utgångsfunktionen i ett. Det är mycket användbart när vi vill skriva ut ett meddelande och stoppa skriptkörningen när ett fel uppstår.
2. Anpassade felhanterare – dessa är användardefinierade funktioner som anropas när ett fel uppstår.
3. PHP-felrapportering – felmeddelandet beroende på dina PHP-felrapporteringsinställningar. Denna metod är mycket användbar i utvecklingsmiljöer när du inte har någon aning om vad som orsakade felet. Informationen som visas kan hjälpa dig att felsöka din applikation.

Exempel på felhantering

Låt oss nu titta på några enkla exempel med felhanteringsrutiner.

Låt oss anta att vi har utvecklat en applikation som använder textfiler för att lagra data. Vi kanske vill kontrollera om filen finns innan vi försöker läsa data från den.

Koden nedan implementerar exemplet ovan.

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

Förutsatt att du sparat filen simple_error.php i phptuts-mappen, öppna URL:en http://localhost/phptuts/simple_error.php

Du kommer att få följande resultat

Som du kan se från ovanstående resultat får det vår applikation att se oprofessionellt ut och kan vara irriterande för användaren.

Vi kommer att modifiera ovanstående kod och skriva en felhanterare för applikationen

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

Förutsatt att du sparat ovanstående kod som error_handling.php, öppna URL:en http://localhost/phptuts/error_handling.php

Obs: det är en bra säkerhetspraxis att visa ett meddelande som det som visas ovan istället för att visa meddelandet som "Filen hittades inte".

Låt oss titta på ett annat exempel som använder en anpassad felhanterare.

Den anpassade felhanteraren kommer att ställas in som standard PHP-felhanteringsfunktion och kommer i princip att visa ett felnummer och ett felmeddelande.

Koden nedan illustrerar implementeringen av exemplet ovan

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

Öppna URL: n http://localhost/phptuts/custom_error_handler.php du kommer att få följande resultat

.

• De tillåter oss att anpassa felmeddelandena.
• Den anpassade felhanteraren kan också inkludera felloggning i en fil/databas, e-post till utvecklaren etc.

Låt oss nu titta på den tredje typen av felhantering. Vi kommer att använda den inbyggda PHP-funktionen error_reporting-funktionen. Den har följande grundläggande syntax

<?php
error_reporting($reporting_level);
?>

HÄR,

• "error_reporting" är PHP-felrapporteringsfunktionen
• "$reporting_level" är valfritt, kan användas för att ställa in rapporteringsnivån. Om ingen rapporteringsnivå har specificerats kommer PHP att använda standardfelrapporteringsnivån som anges i php.ini-filen.

Skillnaden mellan fel och undantag

• Undantag görs och är avsedda att fångas upp medan fel i allmänhet inte går att återställa.
• Undantag hanteras på ett objektorienterat sätt. Detta betyder när ett undantag kastas; ett undantagsobjekt skapas som innehåller undantagsdetaljerna.

Tabellen nedan visar metoderna för undantagsobjekt

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

HÄR,

• "kasta" är nyckelordet som används för att kasta undantaget
• "new Exception(...)" skapar ett undantagsobjekt och skickar "Detta är ett undantagsexempel"-sträng som meddelandeparameter.

Ovanstående kod matar ut följande meddelande.

Vi ska nu titta på ett exempel som implementerar undantagen för kast och fångst.

Vi kommer att modifiera exemplet ovan och inkludera försök, kast och fånga.

Den har följande grundläggande syntax.

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

HÄR,

• "försök{...}" är det kodblock som ska exekveras och som potentiellt kan skapa ett undantag
• "catch(Exception $e){...}" är kodblocket som fångar det kastade undantaget och tilldelar undantagsobjektet till variabeln $e.

Koden nedan visar det grundläggande undantagsexemplet med undantaget try, throw och catch implementerat.

Programmet kastar medvetet ett undantag som det sedan fångar upp.

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

Öppna URL: n http://localhost/phptuts/exception_handling.php Du kommer att få följande resultat.

Det är också möjligt att skapa flera undantag för en php try-sats beroende på typen av undantag.

Se artikeln om MySQL, PHP-dataåtkomst... för implementeringsexempel på flera undantag

Flera undantag

Flera undantag använder multipla försök fångstblock för att hantera de kastade undantagen. Flera undantag är användbara när;

• Du vill visa ett anpassat meddelande beroende på undantaget
• Du vill utföra en unik operation beroende på undantaget

Flödesschemat nedan illustrerar hur flera undantag fungerar

Låt oss titta på ett exempel som använder flera undantag.

Vi kommer att modifiera koden som delar ett tal med den godkända nämnaren.

Vi förväntar oss att två typer av undantag förekommer;

• Dividera med noll
• Division med ett negativt tal

För enkelhetens skull kommer vi endast att visa undantagstypen i våra fångstblock.

PHP inbyggd i Exception-klassen används för att kasta undantag.

Vi kommer att skapa två klasser som utökar undantagsklassen och använder dem för att kasta undantag.

Koden nedan visar implementeringen.

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

Testar koden

Vi antar att du har sparat multiple_exceptions.php i phptuts-mappen.

Bläddra till URL:en http://localhost/phptuts/multiple_exceptions.php

Växla tillbaka till PHP-filen och skicka -1 som parameter som visas i följande diagram.

Bläddra till URL:en http://localhost/phptuts/multiple_exceptions.php.

Vilka resultat får du? Passera 3 som parameter.

Vilka resultat får du?

Sammanfattning

• Fel är oväntade resultat som skapas av PHP-kod
• Felhantering förbättrar applikationens prestanda
• PHP har inbyggda funktioner som kan användas för att anpassa hur PHP rapporterar fel
• Undantag är som fel, men de kan fångas med hjälp av fångstblocket när de kastas.
• Att visa felmeddelanden som visar felinformation anses vara en dålig säkerhetspraxis.