Jakie są typy błędów/wyjątków w PHP?

Question

Accepted Answer

PHP ma dwa równoległy systemy obsługi problemów: tradycyjne **błędy** (ostrzeżenia, powiadomienia, błędy fatalne) i **wyjątki** (oparte na obiektach, przechwytywalne za pomocą try/catch). Nowoczesny PHP ujednolica wiele z tego w hierarchii `Throwable`, a dobra praktyka faworyzuje wyjątki.

## Tradycyjne poziomy błędów

```text
E_NOTICE   → minor issues (e.g. using an undefined variable) — script continues
E_WARNING  → non-fatal problems (e.g. include of a missing file) — continues
E_ERROR / Fatal → serious errors (e.g. calling an undefined function) — script HALTS
E_DEPRECATED → use of deprecated features
```

To klasyczne, oparte na poziomach błędy PHP. Powiadomienia i ostrzeżenia pozwalają skryptowi kontynuować pracę (ale sygnalizują problemy); błędy fatalne go zatrzymują.

## Hierarchia Throwable (nowoczesna, oparta na obiektach)

```text
Throwable (interface)
  ├── Error      → internal PHP/engine errors (TypeError, DivisionByZeroError, ...)
  │                 — typically PROGRAMMING bugs
  └── Exception  → application-level exceptions (the ones you throw and catch)
        ├── RuntimeException, LogicException
        ├── InvalidArgumentException, etc.
        └── your custom exceptions
```

Nowoczesny PHP reprezentuje poważne problemy jako **obiekty** implementujące `Throwable`, podzielone na `Error` (na poziomie silnika, zwykle błędy takie jak `TypeError`) i `Exception` (błędy aplikacji, które zgłaszasz i obsługujesz).

## Przechwytywanie za pomocą try/catch

```php
try {
    $result = riskyOperation();
} catch (InvalidArgumentException $e) {     // catch a SPECIFIC type
    echo "Bad argument: " . $e->getMessage();
} catch (Throwable $e) {                     // catch anything (Error OR Exception)
    log($e);
} finally {
    cleanup();                                // always runs
}
```

Od PHP 7, nawet `Error`y (takie jak `TypeError`) są przechwytywalne jako `Throwable` — więc możesz przechwytywać zarówno błędy, jak i wyjątki.

## Zgłaszanie wyjątków

```php
function divide(int $a, int $b): float {
    if ($b === 0) {
        throw new InvalidArgumentException("Cannot divide by zero");   // raise
    }
    return $a / $b;
}
```

## Konfigurowanie obsługi błędów

```php
error_reporting(E_ALL);         // report ALL errors (development)
ini_set('display_errors', '0'); // production: DON'T show errors to users (log them instead)
set_error_handler(...);          // convert errors to exceptions, custom handling
```

## Dlaczego to ważne

Zrozumienie systemu obsługi błędów i wyjątków w PHP jest ważne dla pisania solidnych aplikacji i efektywnego debugowania.

Znajomość tradycyjnych **poziomów błędów** (powiadomienie/ostrzeżenie/fatal) pomaga w interpretacji komunikatów PHP i rozpoznawaniu wagi problemów, podczas gdy zrozumienie nowoczesnej **hierarchii `Throwable`** (podział między błędami na poziomie silnika `Error`y — zwykle błędy programistyczne — i aplikacyjnymi `Exception`ami, które zgłaszasz i obsługujesz) jest kluczowe dla nowoczesnej obsługi błędów w PHP.

Umiejętności praktyczne — używanie `try/catch/finally` do obsługi wyjątków, przechwytywanie określonych typów, zgłaszanie znaczących wyjątków oraz fakt, że `Error`y są przechwytywalne jako `Throwable` (od PHP 7) — to codzienne wiedza do budowania niezawodnego kodu.

Ważne jest również znanie praktyki produkcyjnej **logowania błędów zamiast wyświetlania ich użytkownikom** (ponieważ wyświetlane błędy ujawniają poufne informacje — problem bezpieczeństwa) jest niezbędne do bezpiecznego wdrożenia.

Nowoczesny PHP faworyzuje podejście oparte na wyjątkach i zorientowane obiektowo, dlatego zrozumienie typów błędów/wyjątków, sposobu ich prawidłowej obsługi i bezpiecznej konfiguracji błędów jest fundamentalną wiedzą do pisania solidnych, debugowalnych i bezpiecznych aplikacji PHP.