PHP 8.1+ ਵਿੱਚ enums ਕਿਵੇਂ ਕਾਰਜ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

**Enums** (enumerations, PHP 8.1+) ਇੱਕ ਕਿਸਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ ਜਿਸ ਵਿੱਚ ਨਾਮ ਦਿੱਤੀ ਗਈ ਮੁੱਲਾਂ ਦਾ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੂਹ ਹੁੰਦਾ ਹੈ — ਇੱਕ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਪ੍ਰਤੀਖਿਆ ਕੀਤੀ ਗਈ ਸੁਵਿਧਾ ਜੋ ਸੀਮਤ ਵਿਕਲਪਾਂ (statuses, roles, types) ਲਈ ਕਿਸਮ ਦੀ ਸੁਰੱਖਿਆ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ ਕਿ ਕਲਾਸ ਕਾਂਸਟੈਂਟ ਜਾਂ ਜਾਦੂਈ ਸਤਰਾਂ ਦੇ ਪੁਰਾਣੇ ਤਰੀਕੇ ਨਾਲੋਂ ਬਹੁਤ ਬਿਹਤਰ ਹੈ।

## ਸ਼ੁੱਧ enums (ਸਿਰਫ ਨਾਮ ਦਿੱਤੇ ਗਏ cases)

```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 ਨਾਮ ਦਿੱਤੇ ਗਏ cases ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਕਿਸਮ ਦੀ ਸਲਾਹ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਸਿਰਫ ਵੈਧ ਮੁੱਲਾਂ ਦੀ ਗਰੈਂਟੀ ਦਿੰਦਾ ਹੈ — arbitrary strings/ints ਪਾਸ ਕਰਨ ਤੋਂ ਬਗ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ।

## Backed enums (cases ਦੇ ਕੋਲ ਇੱਕ 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 enums** ਹਰ case ਨੂੰ ਇੱਕ scalar (string ਜਾਂ int) ਨਾਲ ਸੰਬੰਧਿਤ ਕਰਦੇ ਹਨ — ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਜਾਂ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਨ ਲਈ ਉਪਯੋਗੀ, `from()`/`tryFrom()` ਦੇ ਨਾਲ ਮੁੱਲਾਂ ਤੋਂ ਪਰਿਵਰਤਿਤ ਕਰਨ ਲਈ ਅਤੇ `cases()` ਸਭ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਨ ਲਈ।

## Enums ਕੋਲ methods ਅਤੇ constants ਹੋ ਸਕਦੇ ਹਨ

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

Enums ਵਿੱਚ methods (ਅਤੇ interfaces ਨੂੰ implement ਕਰ) ਹੋ ਸਕਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਹਰ case ਨੂੰ behavior ਜੋੜ ਸਕਦੇ ਹੋ — ਉਹਨਾਂ ਨੂੰ ਸ਼ਕਤੀਸ਼ਾਲੀ domain modeling ਟੂਲ ਬਣਾਉਂਦਾ ਹੈ।

## ਪੁਰਾਣਾ ਤਰੀਕਾ (ਜੋ enums ਦੀ ਥਾਂ ਲੈਂਦੇ ਹਨ)

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

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

Enums (PHP 8.1+) ਇੱਕ ਮਹੱਤਵਪੂਰਨ, ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਪ੍ਰਤੀਖਿਆ ਕੀਤੀ ਗਈ ਸੁਵਿਧਾ ਹੈ ਜੋ ਸੀਮਤ ਮੁੱਲਾਂ ਦੇ ਸਮੂਹ ਵਿੱਚ ਸਹੀ ਕਿਸਮ ਦੀ ਸੁਰੱਖਿਆ ਲਿਆਉਂਦੀ ਹੈ — ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਵਧਦੇ ਹੋਏ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਆਧੁਨਿਕ PHP codebases ਉਹਨਾਂ ਨੂੰ ਗ੍ਰਹਣ ਕਰ ਰਹੇ ਹਨ।

Enums ਤੋਂ ਪਹਿਲੇ, developers ਨੇ fixed option sets (statuses, roles, types, states) ਨੂੰ class constants ਜਾਂ raw strings/ints ਨਾਲ ਪ੍ਰਗਟ ਕੀਤਾ, ਜਿਸ ਨੇ **ਕਿਸਮ ਦੀ ਸੁਰੱਖਿਆ ਨਹੀਂ ਦਿਤੀ** (ਕੋਈ ਵੀ string ਸਵੀਕਾਰ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਸ ਲਈ typos ਜਿਵੇਂ `"actve"` compile ਹੋ ਗਏ ਅਤੇ runtime bugs ਸਾਹਮਣੇ ਆਏ) ਅਤੇ ਵੈਧ ਮੁੱਲਾਂ ਨੂੰ ਸੀਮਤ ਕਰਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਸੀ।

Enums ਇਸ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਨ: ਇੱਕ ਕਿਸਮ ਦੀ ਸਲਾਹ ਵਜੋਂ, ਇੱਕ enum ਸਿਰਫ ਵੈਧ cases ਪਾਸ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ ਦੀ ਗਰੈਂਟੀ ਦਿੰਦਾ ਹੈ, ਅਵੈਧ ਮੁੱਲਾਂ ਨੂੰ runtime bugs ਦੀ ਬਜਾਏ ਕਿਸਮ ਪੱਧਰ 'ਤੇ ਫੜਦਾ ਹੈ — ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸੁਰੱਖਿਆ ਸੁਧਾਰ। **Backed enums** (scalar ਮੁੱਲਾਂ ਦੇ ਨਾਲ) databases ਅਤੇ serialization ਨਾਲ ਸਾਫ਼ ਰੂਪ ਵਿੱਚ ਏਕੀਕਰਣ ਕਰਦੇ ਹਨ (`from()`/`tryFrom()` conversion ਲਈ), ਅਤੇ enums ਵਿੱਚ **methods** ਹੋ ਸਕਦੇ ਹਨ (ਹਰ case ਨੂੰ behavior ਨੀਮ ਕਰਦੇ ਹਨ, ਜਿਵੇਂ ਇੱਕ `label()` ਜਾਂ `isActive()`), ਉਹਨਾਂ ਨੂੰ domain modeling ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਬਣਾਉਂਦੇ ਹਨ।

Pure vs backed enums, ਉਹਨਾਂ ਦੇ methods, ਅਤੇ ਉਹ ਕਿਵੇਂ error-prone ਪੁਰਾਣੇ constant/string approach ਦੀ ਥਾਂ ਲੈਂਦੇ ਹਨ ਨੂੰ ਸਮਝਣਾ ਆਧੁਨਿਕ, type-safe PHP ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ — ਕਿਉਂਕਿ enums ਹੁਣ fixed value sets ਨੂੰ ਮਾਡਲ ਕਰਨ ਲਈ idiomatic ਤਰੀਕਾ ਹਨ ਅਤੇ ਮੌਜੂਦਾ frameworks ਅਤੇ applications ਵਿੱਚ ਪ੍ਰਸ਼ਸਤ ਹਨ, ਉਹਨਾਂ ਵਿੱਚ ਮਾਹਰ ਹੋਣਾ ਆਧੁਨਿਕ PHP ਨਾਲ ਪ੍ਰਮਾਣਿਕਤਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਸੁਰੱਖਿਅਤ, ਵਧੇ ਹੋਏ ਅਤੇ self-documenting ਕੋਡ ਲਿਖਣ ਦੀ ਸਮਰੱਥਾ ਜੋ invalid-value bugs ਦੀ ਪੂਰੀ ਸ਼੍ਰੇਣੀ ਨੂੰ ਰੋਕਦਾ ਹੈ।