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

Question

IT Interview Practice · 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 తో సామర్థ్యం మరియు సురక్షితమైన, మరింత వ్యక్తీకరణీయమైన, స్వయం-డాక్యుమెంటింగ్ కోడ్ రాయడానికి సామర్థ్యాన్ని ప్రతిబింబిస్తుంది, ఇది చెల్లని-విలువ బగ్‌ల యొక్క సంపూర్ణ తరగతిని నిరోధిస్తుంది.

Pure enums (కేవలం పేరుతో కూడిన కేసులు)

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

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

పాత పద్ధతి (enums ఏమి భర్తీ చేస్తుంది)

ఇది ఎందుకు ముఖ్యమైనది

సంబంధిత ప్రశ్నలు