როგორ მუშაობს enum-ები PHP 8.1+-ში?

Question

Accepted Answer

**Enum-ები** (enumerations, PHP 8.1+) განსაზღვრავენ ტიპს დასახელებული მნიშვნელობების ფიქსირებული ნაკრებით — დიდი ხნის განმავლობაში მოსალოდნელი ფიჩার, რომელიც უზრუნველყოფს ტიპის უსაფრთხოებას შეზღუდული ვარიანტების ნაკრებისთვის (სტატუსები, როლები, ტიპები) — ბევრად უკეთესი, ვიდრე ძველი მეთოდი კლასის კონსტანტებით ან magic string-ებით.

## სუფთა enum-ები (მხოლოდ დასახელებული შემთხვევები)

```php
<?php
enum Status {
    case Active;
    case Inactive;
    case Pending;
}

$status = Status::Active;          // a value of type Status
function setStatus(Status $s) {}    // type-safe parameter — only Status values allowed
setStatus(Status::Active);          // ✅
setStatus("active");                 // ❌ TypeError — not a Status
```

სუფთა enum განსაზღვრავს დასახელებული შემთხვევებს. ტიპის hint-ის სახით გამოყენებული, იგი გარანტიას იძლევა მხოლოდ მოქმედი მნიშვნელობების — ელიმინაციას უკეთებს შეცდომებს თვითნებური string-ების/int-ების გადაცემის სხვაგვარად.

## Backed enum-ები (შემთხვევებს აქვთ scalar მნიშვნელობა)

```php
enum Status: string {              // "backed" by string values
    case Active = 'active';
    case Inactive = 'inactive';
    case Pending = 'pending';
}

Status::Active->value;              // 'active' — the backing value
Status::from('active');             // Status::Active — convert FROM the value
Status::tryFrom('bad');             // null if invalid (instead of throwing)
Status::cases();                    // [Active, Inactive, Pending] — all cases
```

**Backed enum-ები** აკავშირებენ თითოეულ შემთხვევას scalar-თან (string ან int) — სასარგებლო მონაცემთა ბაზაში შენახვისთვის ან სერიალიზაციისთვის, `from()`/`tryFrom()` გამოყენებით მნიშვნელობებიდან გადასაყვანად და `cases()` ყველას ჩამოსატვირთად.

## Enum-ებს შეიძლება ჰქონდეთ მეთოდები და კონსტანტები

```php
enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';

public function label(): string {        // methods on the enum
        return match($this) {
            Status::Active => 'Active User',
            Status::Inactive => 'Inactive User',
        };
    }
    public function isActive(): bool {
        return $this === Status::Active;
    }
}
Status::Active->label();   // "Active User"
```

Enum-ებს შეიძლება ჰქონდეთ მეთოდები (და აკმაყოფილებდნენ ინტერფეისებს), რაც საშუალებას გაძლევთ თითოეული შემთხვევის დროს ქცევა დაამაგროთ — რაც მათ ძლევთ დომენის მოდელირების ძლევამოსილ ხელსაწყოს.

## ძველი მეთოდი (რაც enum-ები ჩაანაცვლებს)

```php
// ❌ before enums — class constants or magic strings: no type safety, typo-prone
class Status { const ACTIVE = 'active'; const INACTIVE = 'inactive'; }
function setStatus(string $s) {}   // accepts ANY string — "actve" typo compiles fine
```

## რატომ არის მნიშვნელოვანი

Enum-ები (PHP 8.1+) არის მნიშვნელოვანი, დიდი ხნის განმავლობაში მოსალოდნელი ფიჩار, რომელიც გამოიყენებს სათანადო ტიპის უსაფრთხოებას მნიშვნელობების შეზღუდული ნაკრებისთვის — და მათი გაგება უფრო და უფრო ხდება აუცილებელი, რადგან თანამედროვე PHP კოდბეზები მათ აღიქვამენ.

ენამებამდე, დეველოპერები წარმოადგენდნენ ფიქსირებული ვარიანტების ნაკრებს (სტატუსები, როლები, ტიპები, მდგომარეობები) კლასის კონსტანტებით ან უფრთხო string-ებით/int-ებით, რომლებიც **არ აწვდიდნენ ტიპის უსაფრთხოებას** (ნებისმიერი string იქნა მიღებული, ასე რომ ტიპოგრაფიული შეცდომები როგორიცაა `"actve"` კომპილირებული იყო კარგად და გამოიწვია runtime შეცდომები) და არ ჰქონდა გზა მოქმედი მნიშვნელობების შეზღუდვის.

Enum-ები ამას ხსნიან: ტიპის hint-ის სახით, enum-ი გარანტიას იძლევა მხოლოდ მოქმედი შემთხვევები შეიძლება გადაიცეს, ხელში ან invalid მნიშვნელობების დაჭერა ტიპის დონეზე ვიდრე runtime შეცდომებად — მნიშვნელოვანი უსაფრთხოების გაუმჯობესება. **Backed enum-ები** (scalar მნიშვნელობებით) სუფთად ინტეგრირდებიან მონაცემთა ბაზებთან და სერიალიზაციასთან (`from()`/`tryFrom()` კონვერტაციისთვის), და enum-ებს შეიძლება ჰქონდეთ **მეთოდები** (თითოეული შემთხვევის დროს ქცევის დამაგრება, მაგ. `label()` ან `isActive()`), რაც მათ ძლევთ დომენის მოდელირების ძლევამოსილს.

სუფთა წ backed enum-ების, მათი მეთოდების გაგება და როგორ ისინი ჩაანაცვლებენ შეცდომაში დაკავებული ძველი კონსტანტის/string მეთოდობა არის მნიშვნელოვანი ცოდნა თანამედროვე, ტიპის უსაფრთხო PHP-ის დასაწერად — რადგან enum-ები ახლა არის იდიომატური გზა ფიქსირებული მნიშვნელობის ნაკრებების მოდელირებისთვის და ფართოდ გამოიყენება თანამედროვე ფრეიმვორკებსა და აპლიკაციებში, მათი დაუფლება ასახავს თანამედროვე PHP-ის სიჭკვიანობას და უნარს დაწეროთ უფრო უსაფრთხო, ექსპრესიული, თვითი-დოკუმენტირებული კოდი, რომელიც ხელს უშლის invalid-value შეცდომების მთელ კლასს.