PHP में error/exception types क्या हैं?

Question

Accepted Answer

PHP में समस्याओं के लिए दो समानांतर systems हैं: पारंपरिक **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 के classic, level-based errors हैं। Notices और warnings script को जारी रहने देते हैं (लेकिन समस्याओं का संकेत देते हैं); 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 गंभीर समस्याओं को `Throwable` को implement करने वाले **objects** के रूप में दर्शाता है, जो `Error` (engine-level, आमतौर पर `TypeError` जैसे bugs) और `Exception` (application errors जिन्हें आप उठाते और संभालते हैं) में विभाजित होते हैं।

## try/catch के साथ 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
}
```

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 को configure करना

```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 system को समझना robust applications लिखने और प्रभावी ढंग से debugging करने के लिए महत्वपूर्ण है।

पारंपरिक **error levels** (notice/warning/fatal) को जानना आपको PHP के messages की व्याख्या करने और समस्याओं की गंभीरता को पहचानने में मदद करता है, जबकि आधुनिक **`Throwable` hierarchy** को समझना (engine-level `Error`s — आमतौर पर programming bugs — और application `Exception`s जिन्हें आप throw और catch करते हैं, के बीच विभाजन) आधुनिक PHP error handling की कुंजी है।

व्यावहारिक कौशल — exceptions को संभालने के लिए `try/catch/finally` का उपयोग करना, specific types को catch करना, सार्थक exceptions throw करना, और यह कि `Error`s भी `Throwable` के रूप में catchable हैं (PHP 7 से) — विश्वसनीय code बनाने के लिए रोज़मर्रा का ज्ञान हैं।

महत्वपूर्ण रूप से, **errors को users को दिखाने के बजाय log करने** के production अभ्यास को जानना (चूँकि दिखाए गए errors संवेदनशील जानकारी लीक करते हैं — एक security चिंता) सुरक्षित deployment के लिए आवश्यक है।

आधुनिक PHP exception-based, object-oriented दृष्टिकोण को प्राथमिकता देता है, इसलिए error/exception types को समझना, उन्हें ठीक से कैसे संभाला जाए, और सुरक्षित error configuration, robust, debuggable, secure PHP applications लिखने के लिए मौलिक ज्ञान है।