Koje su vrste grešaka/iznimki u PHP-u?

Question

Accepted Answer

PHP ima dva paralelna sustava za probleme: tradicionalne **greške** (upozorenja, obavijesti, fatalne greške) i **iznimke** (objektno-orijentirane, hvatljive sa try/catch). Moderni PHP ujedinjuje većinu toga pod `Throwable` hijerarhijom, a dobra praksa favorizira iznimke.

## Tradicionalne razine greške

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

Ovo su klasične PHP greške, temeljene na razinama. Obavijesti i upozorenja dozvoljavaju skripti da nastavi (ali signaliziraju probleme); fatalne greške je zaustavljaju.

## Hijerarhija Throwable (moderna, objektno-orijentirana)

```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 predstavlja ozbiljne probleme kao **objekte** koji implementiraju `Throwable`, podijeljene na `Error` (na razini motora, obično greške poput `TypeError`) i `Exception` (greške aplikacije koje vi bacate i obrađujete).

## Hvatanje sa 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, čak i `Error`i (poput `TypeError`) su hvatljivi kao `Throwable` — tako da možete hvatiti i greške i iznimke.

## Bacanje iznimki

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

## Konfiguriranje rukovanja greškama

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

## Zašto je važno

Razumijevanje PHP sustava grešaka i iznimki važno je za pisanje robusnih aplikacija i učinkovito otklanjanje grešaka.

Znanje tradicionalnih **razina greške** (obavijest/upozorenje/fatalno) pomaže vam interpretirati PHP poruke i prepoznati ozbiljnost problema, dok je razumijevanje moderne **`Throwable` hijerarhije** (podjele između greški na razini motora `Error` — obično greške u programiranju — i aplikacijskih `Exception`a koje bacate i obrađujete) ključno za moderno PHP rukovanje greškama.

Praktične vještine — korištenje `try/catch/finally` za rukovanje iznimkama, hvatanje specifičnih tipova, bacanje smislenih iznimki, i činjenica da su čak i `Error`i hvatljivi kao `Throwable` (od PHP 7) — svakodnevno su znanje za izgradnju pouzdanog koda.

Važno je znati proizvodnu praksu **logiranja grešaka umjesto njihova prikaza korisnicima** (jer prikazane greške curljaju osjetljive informacije — sigurnosni problem) što je bitno za siguran uvod u produkciju.

Moderni PHP favorizira iznimkama temeljeni, objektno-orijentirani pristup, tako da razumijevanje tipova grešaka/iznimki, kako ih pravilno obrađivati, i sigurna konfiguracija greške predstavljaju temeljno znanje za pisanje robusnih, otklanjačkih, sigurnih PHP aplikacija.