PHP 8.1+ માં enums કેવી રીતે કાર કરે છે?

Question

Accepted Answer

**Enums** (enumerations, PHP 8.1+) એક નિશ્ચિત નામવાળા મૂલ્યોનો સમૂહ સાથે એક પ્રકાર વ્યાખ્યાયિત કરે છે — એક લાંબા સમયથી અપેક્ષિત વૈશિષ્ટ્ય જે મર્યાદિત વિકલ્પોનાં સમૂહ (statuses, roles, types) માટે પ્રકાર સુરક્ષા પ્રદાન કરે છે, જે પરાણું વર્ગ સ્થિરાંક અથવા जादুई strings પદ્ધતિ કરતા ઘણું વધારે સારું છે.

## શુદ્ધ enums (માત્ર નામવાળાં કેસ)

```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 નામવાળાં કેસ વ્યાખ્યાયિત કરે છે. પ્રકાર સંકેત તરીકે વપરાયેલ, તે માત્ર માન્ય મૂલ્યોની ખાતરી આપે છે — ઇચ્છાધીન strings/ints પાસ કરવાથી બગ દૂર કરે છે.

## Backed enums (કેસ પાસે 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** દરેક કેસને scalar (string અથવા int) સાથે સંબંધિત કરે છે — database માં સંગ્રહ કરવા અથવા serialize કરવા માટે ઉપયોગી, `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 અમલીકરણ) હોઈ શકે છે, જે તમને દરેક કેસ સાથે 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 codebase તેમને અપનાવે છે.

Enums પહેલા, વિકાસકર્તાઓ નિશ્ચિત વિકલ્પ સમૂહ (statuses, roles, types, states) વર્ગ સ્થિરાંક અથવા raw strings/ints સાથે રજૂ કર્યો હતો, જે **કોઈ પ્રકાર સુરક્ષા** પ્રદાન કર્યું નથી (કોઈપણ string સ્વીકૃત હતું, તેથી typos જેવા `"actve"` compile થયા હતા અને runtime bugs પ્રેરિત કર્યા હતા) અને માન્ય મૂલ્યોને મર્યાદિત કરવાનો કોઈ રસ્તો નથી.

Enums આને ઉકેલે છે: પ્રકાર સંકેત તરીકે, enum માત્ર માન્ય કેસ પાસ કરી શકાય તેની ખાતરી આપે છે, runtime bugs તરીકે બદલે પ્રકાર સ્તરે અમાન્ય મૂલ્યો પકડે છે — એક નોંધણીય સુરક્ષા સુધાર. **Backed enums** (scalar મૂલ્યો સાથે) database અને serialization સાથે સ્વચ્છતાથી એકીકૃત છે (`from()`/`tryFrom()` રૂપાંતર માટે), અને enums પાસે **methods** હોઈ શકે છે (દરેક કેસ સાથે behavior જોડવું, દા.ત. `label()` અથવા `isActive()`), તેમને domain modeling માટે શક્તિશાળી બનાવે છે.

શુદ્ધ વર્સેસ backed enums, તેમના methods, અને કેવી રીતે તેઓ error-prone જૂનો સતત/string પદ્ધતિ બદલે છે તે સમજવું આધુનિક, type-safe PHP લખવા માટે મહત્વપૂર્ણ જ્ઞાન છે — કારણ કે enums હવે નિશ્ચિત મૂલ્ય સમૂહ મોડેલ કરવાનું idiomatic રસ્તો છે અને વર્તમાન frameworks અને applications માં વ્યાપક રીતે વપરાય છે, તેમને માસ્ટર કરવું આધુનિક PHP સાથે fluency પ્રતિબિંબિત કરે છે અને સુરક્ષિત, વધુ expressive, self-documenting કોડ લખવાની ક્ષમતા જે invalid-value bugs ના સમગ્ર વર્ગને અટકાવે છે.