PHP లో error/exception types ఏవి?

Question

Accepted Answer

PHP సమస్యల కోసం రెండు సమాంతర వ్యవస్థలను కలిగి ఉంది: సంప్రదాయ **errors** (warnings, notices, fatal errors) మరియు **exceptions** (object-based, try/catch తో catchable). ఆధুনిక PHP వీటిలో చాలా వరకు `Throwable` hierarchy క్రింద ఏకీకృతం చేస్తుంది, మరియు మంచి practice 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` అమలు చేయడం, `Error` (engine-level, సాధారణంగా `TypeError` వంటి bugs) మరియు `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`లు (like `TypeError`) కూడా `Throwable` గా catchable - కాబట్టి మీరు errors మరియు exceptions రెండింటిని catch చేయవచ్చు.

## Exceptions throwing

```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 వ్రాయటానికి మరియు effectively debug చేయటానికి ముఖ్యమైనది.

సంప్రదాయ **error levels** (notice/warning/fatal) తెలుసుకోవడం PHP యొక్క సందేశాలను interpret చేయటానికి మరియు సమస్యల తీవ్రతను గుర్తించటానికి సహాయపడుతుంది, అయితే ఆధునిక **`Throwable` hierarchy** (engine-level `Error`ల మధ్య విభజన — సాధారణంగా programming bugs — మరియు application `Exception`లు మీరు throw మరియు catch చేసేవి) ను అర్థం చేసుకోవడం ఆధുనిక PHP error handling కోసం కీ.

ప్రాక్టికల్ skills — exceptions handle చేయటానికి `try/catch/finally` ను ఉపయోగించడం, నిర్దిష్ట types catch చేయడం, meaningful exceptions throw చేయడం, మరియు `Error`లు కూడా `Throwable` గా catchable అని (PHP 7 నుండి) — రిలయబుల్ కోడ్ బిల్డింగ్ కోసం రోజువారీ జ్ఞానం.

ముఖ్యంగా, **users కు errors display చేయటానికి బదులుగా error logging** యొక్క production practice (since shown errors sensitive information leak చేస్తాయి — a security concern) safe deployment కోసం ఎసెన్షియల్.

ఆధునిక PHP exception-based, object-oriented approach కు అనుకూలం, కాబట్టి error/exception types, వాటిని properly handle చేయటం, మరియు secure error configuration ను అర్థం చేసుకోవడం robust, debuggable, secure PHP applications వ్రాయటానికి fundamental knowledge.