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

Question

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 இன் முழு வகையையும் தடுக்கிறது.