What are the error/exception types in PHP?

Question

IT Interview Practice · Accepted Answer

PHP has two parallel systems for problems: traditional **errors** (warnings, notices, fatal errors) and **exceptions** (object-based, catchable with try/catch). Modern PHP unifies much of this under a `Throwable` hierarchy, and good practice favors exceptions.

## Traditional error levels

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

These are PHP's classic, level-based errors. Notices and warnings let the script continue (but signal problems); fatal errors stop it.

## The Throwable hierarchy (modern, object-based)

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

Modern PHP represents serious problems as **objects** implementing `Throwable`, split into `Error` (engine-level, usually bugs like `TypeError`) and `Exception` (application errors you raise and handle).

## Catching with 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
}
```

Since PHP 7, even `Error`s (like `TypeError`) are catchable as `Throwable` — so you can catch both errors and exceptions.

## Throwing exceptions

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

## Configuring error handling

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

## Why it matters

Understanding PHP's error and exception system is important for writing robust applications and debugging effectively.

Knowing the traditional **error levels** (notice/warning/fatal) helps you interpret PHP's messages and recognize the severity of problems, while understanding the modern **`Throwable` hierarchy** (the split between engine-level `Error`s — usually programming bugs — and application `Exception`s you throw and catch) is key to modern PHP error handling.

The practical skills — using `try/catch/finally` to handle exceptions, catching specific types, throwing meaningful exceptions, and that even `Error`s are catchable as `Throwable` (since PHP 7) — are everyday knowledge for building reliable code.

Importantly, knowing the production practice of **logging errors rather than displaying them to users** (since shown errors leak sensitive information — a security concern) is essential for safe deployment.

Modern PHP favors the exception-based, object-oriented approach, so understanding the error/exception types, how to handle them properly, and secure error configuration is foundational knowledge for writing robust, debuggable, secure PHP applications.

Traditional error levels

The Throwable hierarchy (modern, object-based)

Catching with try/catch

Throwing exceptions

Configuring error handling

Why it matters

Related questions