რა არის შეცდომის/გამონაკლის ტიპები PHP-ში?

Question

Accepted Answer

PHP აქვს ორი პარალელური სისტემა პრობლემებისთვის: ტრადიციული **შეცდომები** (გაფრთხოვება, შენიშვნა, ფატალური შეცდომები) და **გამონაკლისები** (ობიექტზე დაფუძნებული, catchable try/catch-ით). თანამედროვე PHP ბევრს აერთიანებს `Throwable` იერარქიის ქვეშ, და კარგი პრაქტიკა ამჯობინებს გამონაკლისებს.

## ტრადიციული შეცდომის დონეები

```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-ის კლასიკური, დონეზე დაფუძნებული შეცდომები. შენიშვნები და გაფრთხოვებები ზღვრავენ სკრიპტის შესრულებას (მაგრამ სიგნალი აღემატება პრობლემებს); ფატალური შეცდომები აჩერებენ მას.

## Throwable იერარქია (თანამედროვე, ობიექტზე დაფუძნებული)

```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` ინტერფეისს, დაყოფილი `Error` (ძრავის დონეზე, ჩვეულებრივ ხარვეზები როგორიცაა `TypeError`) და `Exception` (აპლიკაციის შეცდომები, რომელსაც თქვენ აბრუნებთ და აკონტროლებთ).

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

PHP 7 დან, `Error`ები (როგორიცაა `TypeError`) ჩაიჭერა როგორც `Throwable` — ასე რომ თქვენ შეგიძლიათ ჩაიჭროთ როგორც შეცდომები, ასევე გამონაკლისები.

## გამონაკლისების გამოწოდება

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

## შეცდომის დამუშავების კონფიგურაცია

```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-ის შეცდომის და გამონაკლის სისტემის გაგება მნიშვნელოვანია მძლავრი აპლიკაციების დასაწერად და ეფექტური გამართვისთვის.

ტრადიციული **შეცდომის დონეების** გაცნობა (notice/warning/fatal) ხელს უწყობს PHP-ის შეტყობინებების ინტერპრეტაციას და პრობლემების სიმძიმის აღიარებას, ხოლო თანამედროვე **`Throwable` იერარქიის** გაგება (დაყოფა ძრავის დონის `Error`-ებს შორის — ჩვეულებრივ პროგრამირების ხარვეზები — და აპლიკაციის `Exception`ებს, რომელსაც თქვენ აბრუნებთ და აკონტროლებთ) მნიშვნელოვანია თანამედროვე PHP შეცდომის დამუშავებისთვის.

პრაქტიკული უნარები — `try/catch/finally` გამოყენება გამონაკლისების დასაკონტროლებლად, კონკრეტული ტიპების ჩაჭრა, მნიშვნელოვანი გამონაკლისების აბრუნება, და რომ `Error`ები ჩაიჭრება როგორც `Throwable` (PHP 7 დან) — ყოველდღიური ცოდნა არის საიმედო კოდის შესაქმნელად.

მნიშვნელოვანია, რომ ტყუილი **შეცდომების შენახვა ჩვეულებრივი საქმიანობის ნაცვლად მომხმარებელთან გამოჩენის** (რადგან ნაჩვენები შეცდომები იჭრება მგრძნობიარე ინფორმაციას — უსაფრთხოების საფრთხე) აუცილებელია უსაფრთხო განვითარებისთვის.

თანამედროვე PHP ამჯობინებს გამონაკლის ზე დაფუძნებული, ობიექტზე ორიენტირებული მიდგომა, აქედან გამომდინარე შეცდომის/გამონაკლის ტიპების გაგება, მათი სწორად დამუშავება, და უსაფრთხო შეცდომის კონფიგურაცია წარმოადგენს საფუძვლად ცოდნას მძლავრი, გამართული, უსაფრთხო PHP აპლიკაციების დასაწერად.