PHP 8.1+ இல் enums எவ்வாறு செயல்படுகிறது?

Question

IT Interview Practice · Accepted Answer

**Enums** (enumerations, PHP 8.1+) ஒரு தரம் (type) வரையறுக்கிறது, இது பெயரிடப்பட்ட மதிப்புகளின் நிலையான தொகுப்புடன் — நீண்ட காலமாக எதிர்பார்க்கப்பட்ட ஒரு அம்சம், இது வகைப்பு மாறிலிகள் அல்லது magical strings இன் பழைய நிலையை விட கட்டுப்படுத்தப்பட்ட விருப்பங்களின் (statuses, roles, types) தொகுப்புகளுக்கு மிகவும் சிறந்த வகையான பாதுகாப்பை வழங்குகிறது.

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

ஒரு pure enum பெயரிடப்பட்ட cases களை வரையறுக்கிறது. ஒரு வகை hint ஆக பயன்படுத்தப்பட்ட போது, இது தன்னிச்சையான 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) ஐ தொடர்புபடுத்துகிறது — ஒரு database இல் சேமிக்க அல்லது serialize செய்ய பயனுள்ளதாக இருக்கும், மதிப்புகளிலிருந்து மாற்ற `from()`/`tryFrom()` மற்றும் அனைத்து cases ஐ பட்டியல் செய்ய `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 ஐ செயல்படுத்த முடியும்), ஒவ்வொரு case க்கும் நடத்தையை இணைக்க உங்களை அனுமதிக்கிறது — அவற்றை powerful domain modeling tools ஆக்குகிறது.

## பழைய முறை (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 நிலையான விருப்பங்களின் தொகுப்புகளை (statuses, roles, types, states) வகைப்பு மாறிலிகள் அல்லது raw strings/ints உடன் குறிப்பிட்டனர், இது **வகை பாதுகாப்பை வழங்கவில்லை** (எந்த string உம் ஏற்றுக்கொள்ளப்பட்டது, எனவே `"actve"` போன்ற typos நன்றாக संकलিত மற்றும் runtime bugs ஐ ஏற்படுத்தியது) மற்றும் செல்லுபடியாகும் மதிப்புகளை கட்டுப்படுத்த வாய்ப்பு இல்லை.

Enums இதை தீர்க்கிறது: ஒரு வகை hint ஆக, enum செல்லுபடியாகும் cases மட்டுமே கடந்து செல்ல முடியும் என்பதை உத்தரவாதம் அளிக்கிறது, runtime bugs இன் பதிலாக வகை நிலையில் செல்லாத மதிப்புகளைப் பிடிக்கிறது — குறிப்பிடத்தக்க பாதுகாப்பு மேம்பாடு. **Backed enums** (scalar மதிப்புகளுடன்) databases மற்றும் serialization உடன் சுத்தமாக ஒருங்கிணைக்கப்படுகிறது (`from()`/`tryFrom()` மாற்றத்திற்கு), மற்றும் enums **methods** வைத்திருக்க முடியும் (ஒவ்வொரு case க்கும் நடத்தையை இணைக்க, உதா. `label()` அல்லது `isActive()`), அவற்றை domain modeling க்கு powerful ஆக்குகிறது.

Pure vs backed enums, அவற்றின் methods, மற்றும் அவை error-prone பழைய constant/string முறைக்கு பதிலாக எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வது நவீன, வகை-பாதுகாப்பான PHP எழுத முக்கியமான ஞ்ஞானம் — enums இப்போது நிலையான மதிப்பு தொகுப்புகளை மாதிரியாக்க idiomatic வழி மற்றும் தற்போதைய frameworks மற்றும் applications இல் பரவலாக பயன்படுத்தப்பட்டுவருவதால், அவற்றை முழுவதுமாக புரிந்துகொள்வது நவீன PHP உடன் fluency ஐ பிரதिபलித்து மற்றும் safer, மேலும் வெளிப்படையான, self-documenting code எழுத முடியும் என்பதை தெரிவிக்கிறது, அது செல்லாத-மதிப்பு bugs இன் முழு வகையையும் தடுக்கிறது.

Pure enums (பெயரிடப்பட்ட cases மட்டுமே)

Backed enums (cases க்கு scalar மதிப்பு உள்ளது)

Enums க்கு methods மற்றும் constants இருக்க முடியும்

பழைய முறை (enums என்ன மாற்றுகிறது)

இது ஏன் முக்கியமான

தொடர்புடைய கேள்விகள்