Lekcja 12: Obsługa Błędów i Wyjątków w PHP

Witaj w dwunastej lekcji kursu PHP! Do tej pory skupialiśmy się na pisaniu kodu, który działa poprawnie w idealnych warunkach. Jednak w rzeczywistym świecie aplikacje często napotykają nieoczekiwane sytuacje: brakujące pliki, problemy z połączeniem do bazy danych, nieprawidłowe dane wejściowe od użytkownika, czy błędy logiczne w samym kodzie. Kluczowym aspektem tworzenia solidnych i niezawodnych aplikacji jest umiejętność eleganckiego radzenia sobie z takimi problemami. W tej lekcji omówimy mechanizmy obsługi błędów i wyjątków w PHP, które pozwalają na kontrolowane zarządzanie sytuacjami awaryjnymi.

Rodzaje Błędów w PHP

PHP rozróżnia kilka typów błędów, które mogą wystąpić podczas wykonywania skryptu. Zrozumienie ich natury jest pierwszym krokiem do efektywnej obsługi.

• Notices (Powiadomienia): Są to najmniej krytyczne błędy. Zazwyczaj wskazują na potencjalny problem w kodzie, ale nie zatrzymują jego wykonywania. Przykładem może być próba odczytu niezdefiniowanej zmiennej lub nieistniejącego indeksu tablicy. W środowisku produkcyjnym powiadomienia często są ukrywane, ale podczas developmentu warto je wyświetlać, aby poprawić jakość kodu.
• Warnings (Ostrzeżenia): Są to poważniejsze błędy niż powiadomienia, ale również domyślnie nie zatrzymują wykonywania skryptu. Wskazują na problem, który może prowadzić do nieoczekiwanego zachowania aplikacji. Przykładem jest próba dołączenia nieistniejącego pliku za pomocą include lub wywołanie funkcji z nieprawidłową liczbą argumentów.
• Fatal Errors (Błędy Krytyczne/Fatalne): Te błędy natychmiast zatrzymują wykonywanie skryptu. Są spowodowane poważnymi problemami, takimi jak wywołanie niezdefiniowanej funkcji, próba utworzenia instancji nieistniejącej klasy, czy przekroczenie limitu pamięci.
• Parse Errors (Syntax Errors - Błędy Składni): Występują, gdy kod PHP zawiera błędy składniowe (np. brakujący średnik, niezamknięty nawias). Parser PHP nie jest w stanie zinterpretować takiego kodu, więc skrypt w ogóle się nie uruchamia. Te błędy są wykrywane na etapie kompilacji, przed wykonaniem.
• Deprecated Errors (Błędy Elementów Przestarzałych): Informują o użyciu funkcji lub funkcjonalności, która jest przestarzała i zostanie usunięta w przyszłych wersjach PHP. Należy unikać używania takich elementów i zastępować je nowszymi odpowiednikami.
• User-generated Errors (Błędy generowane przez użytkownika): PHP pozwala programistom na generowanie własnych błędów (notices, warnings, errors) za pomocą funkcji trigger_error().

Konfiguracja Wyświetlania Błędów

Sposób, w jaki PHP raportuje błędy, można kontrolować za pomocą dyrektyw konfiguracyjnych w pliku php.ini lub dynamicznie w skrypcie za pomocą funkcji ini_set().

• display_errors (on/off): Określa, czy błędy mają być wyświetlane bezpośrednio w przeglądarce (lub na standardowym wyjściu). W środowisku produkcyjnym powinno być ustawione na off ze względów bezpieczeństwa.
• error_reporting: Określa, które typy błędów mają być raportowane. Można używać predefiniowanych stałych, takich jak E_ALL (wszystkie błędy i ostrzeżenia), E_ERROR, E_WARNING, E_NOTICE, E_DEPRECATED, itp., łącząc je operatorami bitowymi. Np. error_reporting(E_ALL & ~E_NOTICE); raportuje wszystko oprócz powiadomień.
• log_errors (on/off): Określa, czy błędy mają być zapisywane do logu serwera (lub pliku określonego przez error_log). W środowisku produkcyjnym zaleca się włączenie logowania błędów.
• error_log: Ścieżka do pliku, w którym mają być zapisywane logi błędów, jeśli log_errors jest włączone.

<?php
// Ustawienia zalecane podczas developmentu (na początku skryptu)
ini_set('display_errors', '1'); // Wyświetlaj błędy
ini_set('display_startup_errors', '1'); // Wyświetlaj błędy startowe (np. parse errors)
error_reporting(E_ALL); // Raportuj wszystkie typy błędów

echo $niezdefiniowanaZmienna; // Wygeneruje Notice

// include 'nieistniejacy_plik.php'; // Wygeneruje Warning i Fatal Error (jeśli display_errors jest on)

// W środowisku produkcyjnym:
// ini_set('display_errors', '0');
// error_reporting(E_ALL & ~E_DEPRECATED & ~E_STRICT); // Lub bardziej restrykcyjnie
// ini_set('log_errors', '1');
// ini_set('error_log', '/sciezka/do/php-error.log');
?>

Obsługa Błędów za pomocą Niestandardowych Handlerów

PHP pozwala na zdefiniowanie własnej funkcji, która będzie wywoływana za każdym razem, gdy wystąpi błąd (z wyjątkiem niektórych błędów fatalnych, jak błędy parsowania czy braku pamięci). Robi się to za pomocą funkcji set_error_handler().

<?php
// Definicja niestandardowego handlera błędów
function mojErrorHandler($poziomBledu, $komunikatBledu, $plikBledu, $liniaBledu) {
    echo "<div style='border: 1px solid red; padding: 10px; margin: 10px;'>";
    echo "<strong>Wystąpił błąd!</strong><br>";
    echo "Poziom: $poziomBledu<br>";
    echo "Komunikat: " . htmlspecialchars($komunikatBledu) . "<br>";
    echo "Plik: " . htmlspecialchars($plikBledu) . "<br>";
    echo "Linia: $liniaBledu<br>";
    echo "</div>";

    // Zwrócenie true zapobiega wykonaniu domyślnego handlera błędów PHP
    // Zwrócenie false (lub brak return) spowoduje, że domyślny handler też się wykona
    return true;
}

// Ustawienie niestandardowego handlera
set_error_handler("mojErrorHandler");

// Wywołanie błędu, który zostanie przechwycony przez nasz handler
echo $testZmiennej; // Notice: Undefined variable

$wynikDzielenia = 10 / 0; // Warning: Division by zero

// Aby przywrócić domyślny handler błędów:
// restore_error_handler();
?>

Niestandardowe handlery błędów dają pełną kontrolę nad tym, jak błędy są prezentowane lub logowane. Można w nich np. wysyłać powiadomienia e-mail do administratora, zapisywać szczegółowe informacje do bazy danych, czy wyświetlać użytkownikowi przyjazną stronę błędu.

Wyjątki (Exceptions)

Wyjątki to obiektowy mechanizm obsługi błędów, wprowadzony w PHP 5. Pozwalają one na bardziej strukturalne i elastyczne zarządzanie sytuacjami wyjątkowymi w kodzie. Zamiast polegać na tradycyjnych błędach PHP, można "rzucać" (throw) obiekty wyjątków, które następnie mogą być "łapane" (catch) i obsługiwane w odpowiednich blokach kodu.

Podstawowa idea wyjątków opiera się na trzech słowach kluczowych: try, catch i throw.

• throw: Służy do "rzucenia" wyjątku. Gdy wyjątek jest rzucany, normalne wykonywanie kodu jest przerywane, a PHP szuka najbliższego bloku catch, który może obsłużyć ten typ wyjątku.
• try: Blok kodu, w którym może wystąpić wyjątek, umieszcza się wewnątrz try { ... }.
• catch: Po bloku try musi następować co najmniej jeden blok catch (TypWyjatku $e) { ... }. Blok catch jest wykonywany tylko wtedy, gdy w odpowiadającym mu bloku try zostanie rzucony wyjątek typu pasującego do zadeklarowanego w catch. Zmienna $e (lub inna nazwa) przechowuje obiekt rzuconego wyjątku.

PHP ma wbudowaną klasę bazową Exception, oraz wiele jej podklas (np. InvalidArgumentException, RuntimeException, PDOException). Można również tworzyć własne, niestandardowe klasy wyjątków, dziedzicząc po klasie Exception lub jej podklasach.

<?php
function podzielLiczby(float $dzielna, float $dzielnik): float {
    if ($dzielnik == 0) {
        // Rzucenie wyjątku, jeśli dzielnik to zero
        throw new Exception("Nie można dzielić przez zero!");
    }
    return $dzielna / $dzielnik;
}

try {
    $wynik1 = podzielLiczby(10, 2);
    echo "Wynik dzielenia 10 / 2 = $wynik1<br>"; // 5

    $wynik2 = podzielLiczby(8, 0);
    // Ten kod się nie wykona, bo powyżej zostanie rzucony wyjątek
    echo "Wynik dzielenia 8 / 0 = $wynik2<br>"; 

} catch (Exception $e) {
    // Przechwycenie i obsługa wyjątku
    echo "<strong>Wystąpił wyjątek:</strong> " . htmlspecialchars($e->getMessage()) . "<br>";
    echo "Plik: " . htmlspecialchars($e->getFile()) . "<br>";
    echo "Linia: " . $e->getLine() . "<br>";
    // echo "Ślad stosu (trace): <pre>" . htmlspecialchars($e->getTraceAsString()) . "</pre><br>";
}

echo "Kontynuacja wykonywania skryptu po bloku try-catch.<br>";
?>

Obiekt wyjątku ($e w przykładzie) dostarcza przydatnych metod do uzyskania informacji o błędzie:

• getMessage(): Zwraca komunikat wyjątku.
• getCode(): Zwraca kod wyjątku (liczba całkowita).
• getFile(): Zwraca pełną ścieżkę do pliku, w którym wyjątek został rzucony.
• getLine(): Zwraca numer linii, w której wyjątek został rzucony.
• getTrace(): Zwraca tablicę reprezentującą ślad stosu (backtrace) do momentu rzucenia wyjątku.
• getTraceAsString(): Zwraca sformatowany jako string ślad stosu.
• getPrevious(): Zwraca poprzedni wyjątek (jeśli wyjątki są zagnieżdżane, od PHP 5.3).

Wiele Bloków catch

Można użyć wielu bloków catch po jednym bloku try, aby obsługiwać różne typy wyjątków w różny sposób. PHP spróbuje dopasować rzucony wyjątek do pierwszego pasującego bloku catch (od góry do dołu).

<?php
class MojWyjatekPliku extends Exception {}
class MojWyjatekBazyDanych extends Exception {}

function operacjaNaPliku(string $sciezka) {
    if (!file_exists($sciezka)) {
        throw new MojWyjatekPliku("Plik '$sciezka' nie istnieje.");
    }
    if (!is_readable($sciezka)) {
        throw new MojWyjatekPliku("Nie można odczytać pliku '$sciezka'.");
    }
    // ... logika operacji na pliku
    echo "Operacja na pliku '$sciezka' zakończona sukcesem.<br>";
}

function operacjaNaBazie(bool $polaczenieUdane) {
    if (!$polaczenieUdane) {
        throw new MojWyjatekBazyDanych("Błąd połączenia z bazą danych.", 500);
    }
    // ... logika operacji na bazie
    echo "Operacja na bazie danych zakończona sukcesem.<br>";
}

try {
    operacjaNaPliku("istniejacy_plik.txt"); // Załóżmy, że istnieje i jest czytelny
    // operacjaNaPliku("nie_istnieje.txt"); // Rzuci MojWyjatekPliku
    operacjaNaBazie(true);
    // operacjaNaBazie(false); // Rzuci MojWyjatekBazyDanych
    // throw new InvalidArgumentException("Nieprawidłowy argument!"); // Rzuci InvalidArgumentException

} catch (MojWyjatekPliku $e) {
    echo "<strong>Błąd pliku:</strong> " . htmlspecialchars($e->getMessage()) . "<br>";
} catch (MojWyjatekBazyDanych $e) {
    echo "<strong>Błąd bazy danych (kod: " . $e->getCode() . "):</strong> " . htmlspecialchars($e->getMessage()) . "<br>";
} catch (Exception $e) { // Ogólny handler dla innych wyjątków dziedziczących po Exception
    echo "<strong>Inny błąd:</strong> " . htmlspecialchars($e->getMessage()) . "<br>";
}

echo "Dalsza część skryptu.<br>";

// Tworzenie pliku dla testu:
// file_put_contents("istniejacy_plik.txt", "test");
?>

Ważne jest, aby bardziej specyficzne typy wyjątków łapać przed bardziej ogólnymi (np. Exception powinien być na końcu listy bloków catch).

Blok finally (od PHP 5.5)

Blok finally można dodać po ostatnim bloku catch. Kod w bloku finally jest wykonywany zawsze po zakończeniu bloku try (i ewentualnie catch), niezależnie od tego, czy wyjątek został rzucony i złapany, czy nie. Jest to przydatne do wykonywania operacji czyszczących, takich jak zamykanie połączeń z bazą danych, zamykanie plików, zwalnianie zasobów itp.

<?php
function przetwarzajZasob($powinienRzucicWyjatek) {
    $zasob = null; // Symulacja otwarcia zasobu
    try {
        echo "Otwieranie zasobu...<br>";
        $zasob = "OTWARTY_ZASOB";

        if ($powinienRzucicWyjatek) {
            throw new Exception("Problem podczas przetwarzania zasobu!");
        }
        echo "Przetwarzanie zasobu zakończone sukcesem.<br>";

    } catch (Exception $e) {
        echo "<strong>Złapano wyjątek:</strong> " . htmlspecialchars($e->getMessage()) . "<br>";
    } finally {
        // Ten blok wykona się zawsze
        echo "Zamykanie zasobu... (aktualny stan: $zasob)<br>";
        $zasob = "ZAMKNIETY_ZASOB"; // Symulacja zamknięcia
        echo "Zasób został zamknięty.<br>";
    }
}

echo "<h3>Test 1: Bez wyjątku</h3>";
przetwarzajZasob(false);

echo "<h3>Test 2: Z wyjątkiem</h3>";
przetwarzajZasob(true);
?>

Niestandardowy Handler Wyjątków

Podobnie jak dla błędów, można ustawić globalny, niestandardowy handler dla nieprzechwyconych wyjątków za pomocą funkcji set_exception_handler(). Ta funkcja zostanie wywołana, jeśli wyjątek zostanie rzucony i nie zostanie złapany przez żaden blok catch.

<?php
function mojExceptionHandler(Throwable $wyjatek) { // Od PHP 7, Throwable łapie Exception i Error
    echo "<div style='background-color: #ffdddd; border: 1px solid darkred; padding: 15px; margin: 10px;'>";
    echo "<h2>Nieprzechwycony Wyjątek!</h2>";
    echo "<p><strong>Komunikat:</strong> " . htmlspecialchars($wyjatek->getMessage()) . "</p>";
    echo "<p><strong>Plik:</strong> " . htmlspecialchars($wyjatek->getFile()) . " (linia: " . $wyjatek->getLine() . ")</p>";
    echo "<p><strong>Ślad stosu:</strong></p>";
    echo "<pre>" . htmlspecialchars($wyjatek->getTraceAsString()) . "</pre>";
    echo "</div>";
    // W środowisku produkcyjnym tutaj logowalibyśmy błąd i wyświetlali użytkownikowi ogólną stronę błędu.
}

set_exception_handler('mojExceptionHandler');

// throw new Exception("To jest testowy nieprzechwycony wyjątek!");

// Przykład, który może rzucić Error (np. TypeError jeśli strict_types=1)
// function testTypowania(int $a) { var_dump($a); }
// testTypowania("nie int");
?>

Od PHP 7, zarówno tradycyjne błędy PHP (takie jak Fatal Errors), jak i wyjątki implementują interfejs Throwable. Oznacza to, że można użyć catch (Throwable $t) do łapania zarówno wyjątków, jak i wielu błędów, które wcześniej nie były łapalne. Klasy Error i Exception dziedziczą po Throwable.

Kiedy używać Błędów, a kiedy Wyjątków?

• Błędy PHP (Notices, Warnings): Często sygnalizują problemy, które niekoniecznie przerywają działanie aplikacji, ale wskazują na potencjalne nieścisłości w kodzie lub nieoczekiwane warunki. Warto je monitorować podczas developmentu.
• Wyjątki: Są preferowane w programowaniu obiektowym i w sytuacjach, gdzie błąd jest na tyle poważny, że normalny przepływ programu nie może być kontynuowany, lub gdy chcemy jawnie zasygnalizować problem, który powinien być obsłużony przez kod wywołujący. Wyjątki pozwalają na czystsze oddzielenie logiki obsługi błędów od głównej logiki aplikacji.

Dobrą praktyką jest konwertowanie krytycznych błędów PHP na wyjątki za pomocą niestandardowego error handlera, aby móc je obsługiwać w spójny sposób za pomocą bloków try-catch.

Podsumowanie Lekcji

W tej lekcji nauczyliśmy się, jak PHP radzi sobie z błędami i sytuacjami wyjątkowymi. Poznaliśmy różne typy błędów, sposoby ich konfiguracji i raportowania, oraz jak tworzyć niestandardowe handlery błędów. Zgłębiliśmy również potężny mechanizm wyjątków, ucząc się, jak rzucać (throw), łapać (try-catch) i obsługiwać wyjątki, w tym użycie wielu bloków catch oraz bloku finally. Dowiedzieliśmy się także o interfejsie Throwable i możliwości ustawienia globalnego handlera dla nieprzechwyconych wyjątków.

Efektywna obsługa błędów i wyjątków jest fundamentem tworzenia stabilnych, niezawodnych i bezpiecznych aplikacji PHP. W następnej lekcji zajmiemy się praktycznymi aspektami pracy z systemem plików – odczytem, zapisem i zarządzaniem plikami oraz katalogami.