Mitkä ovat PHP:n virhe- ja poikkeuslajit?

Question

Accepted Answer

PHP:llä on kaksi rinnakkaista järjestelmää ongelmille: perinteiset **virheet** (varoitukset, huomautukset, vakavat virheet) ja **poikkeukset** (oliopohjaiset, siepattavissa try/catch-konstruktiolla). Moderni PHP yhdistää suuren osan tästä `Throwable`-hierarkian alle, ja hyvä käytäntö suosii poikkeuksia.

## Perinteiset virhetasot

```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
```

Nämä ovat PHP:n klassiset, tasopohjaisia virheitä. Huomautukset ja varoitukset sallivat skriptin jatkamisen (mutta signaloivat ongelmia); vakavat virheet pysäyttävät sen.

## Throwable-hierarkia (moderni, oliopohjaiset)

```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
```

Moderni PHP esittää vakavia ongelmia **olioina**, jotka toteuttavat `Throwable`-rajapinnan, jaettuina `Error`-luokkaan (moottoritason, yleensä bugit kuten `TypeError`) ja `Exception`-luokkaan (sovellusvirheet, jotka nostat ja käsittelet).

## Sieppaaminen try/catch-konstruktiolla

```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
}
```

PHP 7:stä lähtien jopa `Error`t (kuten `TypeError`) ovat siepattavissa `Throwable`-luokkana — joten voit siepata sekä virheet että poikkeukset.

## Poikkeusten heittäminen

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

## Virheiden käsittelyn konfigurointi

```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
```

## Miksi se on tärkeää

PHP:n virhe- ja poikkelusjärjestelmän ymmärtäminen on tärkeää kestävien sovellusten kirjoittamiselle ja tehokkaalle debuggaukselle.

Perinteiset **virhetasot** (huomautus/varoitus/vakava) auttavat sinua tulkitsemaan PHP:n viestejä ja tunnistamaan ongelmien vakavuuden, kun taas moderni **`Throwable`-hierarkia** (jakauma moottoritason `Error`ien — yleensä ohjelmointibuggit — ja sovelluksen `Exception`ien välillä, jotka heität ja käsittelet) on avain moderniin PHP-virheiden käsittelyyn.

Praktiset taidot — `try/catch/finally`-konstruktion käyttäminen poikkeusten käsittelyyn, tiettyjen tyyppien sieppaaminen, merkityksellisten poikkeusten heittäminen ja se, että jopa `Error`t ovat siepattavissa `Throwable`-luokkana (PHP 7:stä lähtien) — ovat päivittäistä tietoa luotettavan koodin rakentamiselle.

Tärkeää on tietää tuotannon käytännöistä **virheiden lokittaminen näyttämisen sijaan käyttäjille** (koska näytetyt virheet paljastuvat herkät tiedot — turvallisuusriski) on olennaista turvalliselle käyttöönotolle.

Moderni PHP suosii poikkeusten perusteella olevaa, oliosuuntautunutta lähestymistapaa, joten virhe- ja poikkeluslajien ymmärtäminen, niiden oikea käsittely ja turvallinen virheenkäsittelyn konfigurointi ovat perustietoja kestävien, debuggattavissa olevien ja turvallisten PHP-sovellusten kirjoittamiselle.