Bagaimana cara kerja enum di PHP 8.1+?

Question

Accepted Answer

**Enum** (enumerations, PHP 8.1+) mendefinisikan sebuah tipe dengan sekumpulan nilai bernama yang tetap — fitur yang dinanti-nantikan yang memberikan type safety untuk set opsi terbatas (statuses, roles, types) jauh lebih baik daripada pendekatan lama menggunakan class constants atau magic strings.

## Pure enums (hanya named 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
```

Sebuah pure enum mendefinisikan named cases. Ketika digunakan sebagai type hint, enum menjamin hanya nilai-nilai yang valid — menghilangkan bug dari passing arbitrary strings/ints.

## Backed enums (cases memiliki scalar value)

```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** mengasosiasikan setiap case dengan scalar (string atau int) — berguna untuk menyimpan di database atau serializing, dengan `from()`/`tryFrom()` untuk konversi dari values dan `cases()` untuk menampilkan semua.

## Enums dapat memiliki methods dan 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"
```

Enum dapat memiliki methods (dan mengimplementasikan interfaces), memungkinkan Anda melampirkan behavior ke setiap case — menjadikan mereka powerful domain modeling tools.

## Cara lama (yang digantikan 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
```

## Mengapa ini penting

Enum (PHP 8.1+) adalah fitur penting dan dinanti-nantikan yang membawa type safety yang tepat ke set nilai terbatas — dan memahaminya semakin penting seiring modern PHP codebases mengadopsinya.

Sebelum enum, developer merepresentasikan fixed option sets (statuses, roles, types, states) dengan class constants atau raw strings/ints, yang tidak menawarkan **type safety** (string apapun diterima, jadi typos seperti `"actve"` dikompilasi dengan baik dan menyebabkan bugs runtime) dan tidak ada cara untuk mengkonstrain nilai-nilai yang valid.

Enum mengatasi ini: sebagai type hint, enum menjamin hanya valid cases yang bisa dipassing, menangkap invalid values di type level daripada sebagai bugs runtime — improvement safety yang signifikan. **Backed enums** (dengan scalar values) terintegrasi dengan baik ke databases dan serialization (`from()`/`tryFrom()` untuk konversi), dan enum dapat memiliki **methods** (melampirkan behavior ke setiap case, misalnya `label()` atau `isActive()`), menjadikan mereka powerful untuk domain modeling.

Memahami pure vs backed enums, methods mereka, dan bagaimana mereka menggantikan pendekatan lama yang error-prone dengan constant/string adalah pengetahuan penting untuk menulis modern, type-safe PHP — karena enum sekarang adalah cara idiomatik untuk model fixed value sets dan banyak digunakan dalam frameworks dan applications saat ini, menguasai mereka mencerminkan fluency dengan modern PHP dan kemampuan untuk menulis safer, lebih expressive, self-documenting code yang mencegah seluruh class dari invalid-value bugs.