Cum funcționează gestionarea erorilor și excepțiilor…

Tratamentul erorilor și excepțiilor în PHP permite controlul execuției programului în cazul apariției situațiilor incorecte, prevenirea blocărilor fatale și furnizarea de informații semnificative utilizatorului.

Erori

Erorile sunt probleme care apar la nivelul interpretatorului PHP. Ele pot fi sintactice, logice sau pot apărea la accesarea resurselor inexistente. Nivelurile de erori sunt definite de constante (E_ERROR, E_WARNING, E_NOTICE etc.) și pot fi configurate cu error_reporting și display_errors.

Pentru gestionarea erorilor, se folosesc funcții-handler personalizate, înregistrate cu set_error_handler(). Această funcție interceptează erorile (cu excepția E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING), permițând înregistrarea lor, afișarea unui mesaj, oprirea scriptului sau continuarea acestuia.

<?php
// Funcție personalizată de gestionare a erorilor
function myErrorHandler($errno, $errstr, $errfile, $errline) {
    // Înregistrare eroare
    error_log("Eroare [$errno]: $errstr în fișierul $errfile la linia $errline");

    // Afișare mesaj utilizatorului (în funcție de mediu)
    if (ini_get('display_errors')) {
        echo "A apărut o eroare: [$errno] $errstr<br>";
        echo "În fișier: $errfile la linia: $errline<br>";
    }

    // Oprire script în caz de erori critice
    if ($errno == E_USER_ERROR) {
        die("Eroare critică. Script oprit.");
    }

    // Continuare cu gestionarea standard PHP dacă funcția returnează false
    // return false;
}

// Înregistrare funcție-handler
set_error_handler("myErrorHandler");

// Exemplu de eroare
// echo $undeclaredVar; // Va genera E_NOTICE

Excepții

Excepțiile sunt obiecte care sunt aruncate în cazul apariției unor situații excepționale. Ele permit structurarea codului și gestionarea mai flexibilă a fluxului de execuție decât gestionarea tradițională a erorilor.

Excepțiile sunt gestionate cu ajutorul construcției try...catch...finally:

try: blocul de cod în care poate apărea o excepție.
catch: blocul de cod care se execută dacă în try sau alt catch a fost aruncată o excepție de tipul specificat. Se pot folosi mai multe catch pentru diferite tipuri de excepții.
finally: (disponibil în PHP 5.5) blocul de cod care se execută întotdeauna, indiferent dacă a fost aruncată sau nu o excepție.

<?php
function divide($a, $b) {
    if ($b === 0) {
        // Aruncare excepție din clasa Exception încorporată
        throw new Exception("Împărțirea la zero nu este posibilă.");
    }
    return $a / $b;
}

try {
    // Încercare de executare a codului care poate arunca excepție
    echo divide(10, 2) . "<br>";
    echo divide(5, 0) . "<br>"; // aici va fi generată o excepție
    echo "Acest cod nu va fi executat dacă linia anterioară aruncă excepție.";
} catch (Exception $e) {
    // Capturare excepție
    echo "Excepție capturată: " . $e->getMessage() . "<br>";
    // Se pot obține fișierul, linia și stiva de apeluri
    // echo "În fișier: " . $e->getFile() . " la linia: " . $e->getLine() . "<br>";
    // echo "Stiva de apeluri:<pre>" . $e->getTraceAsString() . "</pre>";
} finally {
    // Acest bloc se execută întotdeauna
    echo "Operație finalizată.<br>";
}

Clase de excepții

PHP oferă clasa de bază Exception, din care moștenesc alte clase de excepții încorporate (de exemplu, InvalidArgumentException, RuntimeException). Se pot crea propriile clase de excepții, moștenind de la Exception sau din clasele sale derivate, pentru o reprezentare mai precisă a tipurilor de erori.

<?php
class MyCustomException extends Exception {
    // Se pot adăuga proprietăți și metode proprii
}

function processData($data) {
    if (empty($data)) {
        // Aruncare excepție personalizată
        throw new MyCustomException("Datele pentru procesare lipsesc.");
    }
    // ... procesare date
}

try {
    processData([]);
} catch (MyCustomException $e) {
    echo "Excepție personalizată capturată: " . $e->getMessage() . "<br>";
} catch (Exception $e) {
    // Gestionare alte tipuri de excepții
    echo "Altă excepție capturată: " . $e->getMessage() . "<br>";
}

Principii generale

Nu captura erori pe care nu le poți trata. Dacă nu știi cum să reacționezi corect la o anumită eroare, las-o să se propague mai sus pentru a fi gestionată de alt handler.
Excepțiile sunt mai potrivite pentru situații așteptate, dar excepționale (de exemplu, eroare de introducere a datelor, imposibilitatea de a conecta la baza de date). Erorile indică adesea probleme în cod sau în mediul de execuție.
Loghează erorile și excepțiile. Acest lucru este critic pentru depanare și monitorizare.
Nu dezvălui informații sensibile utilizatorului în mesajele de eroare.
Folosește set_exception_handler() pentru gestionarea excepțiilor neprinse. Acest lucru previne erorile fatale și permite o degradare elegantă.

<?php
// Handler pentru excepții neprinse
function myExceptionHandler($exception) {
    error_log("Excepție neprinsă: " . $exception->getMessage());
    // Redirecționare către pagina de eroare, afișare mesaj general etc.
    echo "A apărut o eroare neașteptată pe server. Încearcă mai târziu.";
}

set_exception_handler('myExceptionHandler');

// Acest cod va arunca o excepție care va fi capturată de myExceptionHandler
// throw new Exception("Aceasta este o excepție neprinsă.");

Astfel, utilizarea corectă a mecanismelor de gestionare a erorilor și excepțiilor este fundamentală pentru crearea de aplicații PHP fiabile și ușor de întreținut.

Cum funcționează gestionarea erorilor și excepțiilor în PHP?