PHP 8.1+లో enums ఎలా పని చేస్తాయి?

Question

Accepted Answer

**Enums** (enumerations, PHP 8.1+) నిర్ణీత సంఖ్యలో పేరుతో కూడిన విలువల సమితిని నిర్వచించే ఒక రకాన్ని నిర్ణయిస్తాయి — పాతపద్ధతి వర్గ స్థిరాంకాలు లేదా మాయా చేతులను కంటే సందర్భానికి సంబంధించిన ఐచ్ఛికాల కోసం చాలా మెరుగైన రకం భద్రతను అందించే ఎక్కువ కాలం ఎదురుచూస్తున్న ఫీచర్.

## Pure 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 పేర్కొన్న కేసులను నిర్వచిస్తుంది. రకం సూచికగా ఉపయోగించినప్పుడు, ఇది చెల్లుబాటు అయిన విలువలను మాత్రమే గ్యారెంటీ ఇస్తుంది — ఏకపక్ష స్ట్రింగ్‌లు/ints ను పాస్ చేయడం నుండి బగ్‌లను తొలగిస్తుంది.

## Backed enums (కేసులకు స్కేలార్ విలువ ఉంది)

```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** ప్రతి కేసును స్కేలార్ (స్ట్రింగ్ లేదా int) తో సంబంధం కల్పిస్తాయి — డేటాబేస్‌లో నిల్వ చేయడం లేదా సీరియలైజ్ చేయడానికి ఉపయోగకరం, విలువల నుండి మార్చడానికి `from()`/`tryFrom()` మరియు అన్నింటిని జాబితా చేయడానికి `cases()` ఉపయోగం.

## Enums పద్ధతులు మరియు స్థిరాంకాలను కలిగి ఉండవచ్చు

```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 పద్ధతులను (మరియు ఇంటర్‌ఫేస్‌లను అమలు చేయవచ్చు), ప్రతి కేసుకు ప్రవర్తనను జతచేయడానికి నిర్వహణ చేస్తుంది — వాటిని శక్తివంతమైన డొమైన్ మోడలింగ్ సాధనాలుగా చేస్తుంది.

## పాత పద్ధతి (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 కోడ్‌బేసులు వాటిని ఆమోదించేటప్పుడు ఎక్కువ అవసరమైనది.

Enumsకు ముందు, డెవలపర్‌లు స్థిర ఐచ్ఛికాల సమితులను (స్థితులు, పాత్రలు, రకాలు, స్థితులు) వర్గ స్థిరాంకాలు లేదా ముడి స్ట్రింగ్‌లు/ints తో సూచించారు, ఇవి **రకం భద్రతను అందించలేదు** (ఏదైనా స్ట్రింగ్ ఆమోదించబడింది, కాబట్టి `"actve"` వంటి టైపోలు సంకలనం చేయబడ్డాయి మరియు రన్‌టైమ్ బగ్‌లకు కారణమయ్యాయి) మరియు చెల్లుబాటు అయిన విలువలను నియంత్రించే మార్గం లేదు.

Enums దీనిని పరిష్కరిస్తుంది: రకం సూచికగా, ఒక enum కేవలం చెల్లుబాటు అయిన కేసులను పాస్ చేయగలదని గ్యారెంటీ ఇస్తుంది, చెల్లని విలువలను రకం స్థరంలో రన్‌టైమ్ బగ్‌ల కంటే ఉపటంకించి, ముఖ్యమైన భద్రత మెరుగుదల. **Backed enums** (స్కేలార్ విలువలతో) డేటాబేసులు మరియు సీరియలైజేషన్‌లో శుభ్రంగా సమీకరణం చేస్తాయి (`from()`/`tryFrom()` మార్పిడి కోసం), మరియు enums **పద్ధతులను** కలిగి ఉండవచ్చు (ప్రతి కేసుకు ప్రవర్తనను జతచేస్తాయి, ఉదా `label()` లేదా `isActive()`), వాటిని డొమైన్ మోడలింగ్ కోసం శక్తివంతమైనవిగా చేస్తుంది.

Pure vs backed enums, వాటి పద్ధతులు, మరియు సంభావ్య-దోషపూర్ణమైన పాత స్థిరాంకం/స్ట్రింగ్ విధానానికి భర్తీ చేయడానికి ఎలా కీలకమైనవో అర్థం చేసుకోవడం ఆధునిక, రకం-సురక్ష PHP రాయడానికి ముఖ్యమైనది — ఎందుకంటే enums ఇప్పుడు స్థిర విలువ సమితులను నమూనా చేయడానికి విధానం, ప్రస్తుత ఫ్రేమ్‌వర్క్‌లు మరియు అనువర్తనాలలో విస్తృతంగా ఉపయోగించబడుతున్నాయి, వాటిని నైపుణ్యం చేయడం ఆధునిక PHP తో సామర్థ్యం మరియు సురక్షితమైన, మరింత వ్యక్తీకరణీయమైన, స్వయం-డాక్యుమెంటింగ్ కోడ్ రాయడానికి సామర్థ్యాన్ని ప్రతిబింబిస్తుంది, ఇది చెల్లని-విలువ బగ్‌ల యొక్క సంపూర్ణ తరగతిని నిరోధిస్తుంది.