PHP ਵਿੱਚ error/exception ਕਿਸਮਾਂ ਕੀ ਹਨ?

Question

Accepted Answer

PHP ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਲਈ ਦੋ ਸਮਾਨਾਂਤਰ ਸਿਸਟਮ ਹਨ: ਰਵਾਇਤੀ **errors** (warnings, notices, fatal errors) ਅਤੇ **exceptions** (object-based, try/catch ਨਾਲ catchable)। ਜਾਧੁਨਕ PHP ਇਸ ਦੀ ਬਹੁਤ ਕੁਝ `Throwable` hierarchy ਦੇ ਅਧੀਨ ਏਕੀਕ੍ਰਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਚੰਗੀ ਅਭਿਆਸ exceptions ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੀ ਹੈ।

## ਰਵਾਇਤੀ 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
```

ਇਹ PHP ਦੀਆਂ ਕਲਾਸਿਕ, level-based errors ਹਨ। Notices ਅਤੇ warnings ਸਕ੍ਰਿਪਟ ਨੂੰ ਜਾਰੀ ਰੱਖਣ ਦਿੰਦੀਆਂ ਹਨ (ਪਰ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਸੰਕੇਤ ਕਰਦੀਆਂ ਹਨ); fatal errors ਇਸ ਨੂੰ ਰੋਕ ਦਿੰਦੀਆਂ ਹਨ।

## Throwable hierarchy (ਜਾਧੁਨਕ, 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
```

ਜਾਧੁਨਕ PHP ਗੰਭੀਰ ਸਮੱਸਿਆਵਾਂ ਨੂੰ **objects** ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਸਤੁਤ ਕਰਦਾ ਹੈ ਜੋ `Throwable` ਨੂੰ implement ਕਰਦੇ ਹਨ, `Error` (engine-level, ਆਮ ਤੌਰ 'ਤੇ bugs ਜਿਵੇਂ `TypeError`) ਅਤੇ `Exception` (application errors ਜੋ ਤੁਸੀਂ raise ਕਰਦੇ ਅਤੇ handle ਕਰਦੇ ਹੋ) ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ।

## try/catch ਨਾਲ catching

```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 ਦੇ ਬਾਅਦ, ਇੱਥੋ `Error`s (ਜਿਵੇਂ `TypeError`) ਵੀ `Throwable` ਦੇ ਰੂਪ ਵਿੱਚ catchable ਹਨ — ਇਸ ਲਈ ਤੁਸੀਂ errors ਅਤੇ exceptions ਦੋਵਾਂ ਨੂੰ catch ਕਰ ਸਕਦੇ ਹੋ।

## Exceptions throw ਕਰਨਾ

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

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

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

PHP ਦੇ error ਅਤੇ exception ਸਿਸਟਮ ਨੂੰ ਸਮਝਣਾ robust applications ਲਿਖਣ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ debug ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਰਵਾਇਤੀ **error levels** (notice/warning/fatal) ਨੂੰ ਜਾਣਨਾ PHP ਦੇ ਸੰਦੇਸ਼ਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਅਤੇ ਸਮੱਸਿਆਵਾਂ ਦੀ ਗੰਭੀਰਤਾ ਨੂੰ ਪਛਾਣਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਜਾਧੁਨਕ **`Throwable` hierarchy** (engine-level `Error`s — ਆਮ ਤੌਰ 'ਤੇ programming bugs — ਅਤੇ application `Exception`s ਜੋ ਤੁਸੀਂ throw ਅਤੇ catch ਕਰਦੇ ਹੋ) ਵਿੱਚ ਵੰਡ ਨੂੰ ਸਮਝਣਾ ਜਾਧੁਨਕ PHP error handling ਲਈ ਮੁੱਖ ਹੈ।

ਵਿਹਾਰਕ ਹੁਨਰ — exceptions ਨੂੰ handle ਕਰਨ ਲਈ `try/catch/finally` ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਖਾਸ ਕਿਸਮਾਂ ਨੂੰ catch ਕਰਨਾ, ਅਰਥਪੂਰਨ exceptions throw ਕਰਨਾ, ਅਤੇ ਇਹ ਕਿ ਇੱਥੋ `Error`s ਵੀ `Throwable` ਦੇ ਰੂਪ ਵਿੱਚ catchable ਹਨ (PHP 7 ਤੋਂ ਬਾਅਦ) — reliable code ਬਣਾਉਣ ਲਈ ਰੋਜ਼ਮਰ੍ਹਾ ਦਾ ਗਿਆਨ ਹਨ।

ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਇਹ ਹੈ ਕਿ **production practice ਵਿੱਚ errors ਨੂੰ log ਕਰਨਾ** ਬਜਾਏ ਇਸ ਦੇ ਕਿ ਉਨ੍ਹਾਂ ਨੂੰ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਦਿਖਾਇਆ ਜਾਵੇ (ਕਿਉਂਕਿ ਦਿਖਾਈਆਂ ਗਈਆਂ errors ਸੰਵੇਦਨਸ਼ੀਲ ਜਾਣਕਾਰੀ ਲੀਕ ਕਰਦੀਆਂ ਹਨ — ਇੱਕ security ਚਿੰਤਾ) ਸੁਰੱਖਤ deployment ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਜਾਧੁਨਕ PHP exception-based, object-oriented ਪਹੁੰਚ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ error/exception ਕਿਸਮਾਂ ਨੂੰ ਸਮਝਣਾ, ਉਨ੍ਹਾਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ handle ਕਰਨਾ, ਅਤੇ secure error configuration ਨੂੰ ਸਮਝਣਾ robust, debuggable, secure PHP applications ਲਿਖਣ ਲਈ ਬੁਨਿਆਦੀ ਗਿਆਨ ਹੈ।