PHP 8 News: Enumerations
Tags: php
Published: 2024-03-09 23:35:24

**Enumerations** were introduced as a new feature in `PHP 8.1`. **Enumerations**, often referred to as enums, provide a way to define a set of named constants in `PHP`. They are a data type that consists of a fixed set of named values, which cannot be changed after declaration.

**Defining an Enumeration:**

To define an **enumeration**, you use the `enum` keyword followed by the name of the enumeration and a list of comma-separated constant values within braces `{}`.

```php
enum Status {
    case Pending;
    case Approved;
    case Rejected;
}
```
**Using Enumerations:**

Once you've defined an **enumeration**, you can use it just like any other data type in `PHP`.

```php
$status = Status::Pending;
```

**Accessing Enumerations:**

You access enumeration values using the double colon syntax 
`::`.

```php
$status = Status::Pending;
```

**Type Safety:**

**Enumerations** provide type **safety**. This means that if a function or method expects an enumeration value, passing anything else will result in a type error.

```php
function processStatus(Status $status) {
    // Processing code
}

$status = Status::Approved;
processStatus($status); // Valid

$invalidStatus = 'Pending';
processStatus($invalidStatus); // Type error
```

**Iteration:**

You can iterate over the values of an **enumeration** using a foreach loop.

```php
foreach (Status::cases() as $status) {
    echo $status;
}
```

**Comparison:**

**Enumerations** can be compared for equality using the `===` operator.

```php
$status1 = Status::Pending;
$status2 = Status::Pending;

if ($status1 === $status2) {
    echo "Statuses are equal";
}
```

**Backing Values:**

By default, each constant in an **enumeration** has an implicit integer value starting from 0. However, you can explicitly assign values to the constants.

```php
enum Status {
    case Pending = 1;
    case Approved = 2;
    case Rejected = 3;
}
```

**Additional Methods:**

**Enumerations** support additional methods like `name()`, `value()`, `keys()`, `values()`, `ordinal()`, and `jsonSerialize()`, which provide various functionalities like getting the name of the constant, its value, keys, values, ordinal position, and serialization respectively.

**Enumerations** in `PHP 8.1` provide a convenient and type-safe way to define a set of related constants, improving code readability, maintainability, and reducing the likelihood of errors related to using incorrect constant values.

### More examples

**Basic Enumeration:**

```php
enum Direction {
    case North;
    case South;
    case East;
    case West;
}

$direction = Direction::North;
echo $direction; // Output: Direction::North
```

**Enumeration with Backing Values:**

```php
enum Priority {
    case Low = 1;
    case Medium = 5;
    case High = 10;
}

$priority = Priority::High;
echo $priority->value(); // Output: 10
```

**Type Safety:**

```php
function processPriority(Priority $priority) {
    echo "Processing priority: $priority";
}

$priority = Priority::Medium;
processPriority($priority); // Valid

$invalidPriority = 'Low';
processPriority($invalidPriority); // Type error
```

**Iteration:**

```php
foreach (Priority::cases() as $priority) {
    echo $priority . "\n";
}
// Output:
// Priority::Low
// Priority::Medium
// Priority::High
```

**Comparison:**

```php
$priority1 = Priority::Low;
$priority2 = Priority::Low;

if ($priority1 === $priority2) {
    echo "Priorities are equal\n";
}
// Output: Priorities are equal
```

**Using Methods:**

```php
$priority = Priority::Medium;
echo $priority->name() . "\n"; // Output: Medium
echo $priority->ordinal() . "\n"; // Output: 2
echo json_encode($priority) . "\n"; // Output: "2"
```

These examples showcase different aspects of **enumerations** in `PHP 8.1`, including defining enums, assigning backing values, ensuring type safety, iterating over enum values, comparing enum values, and utilizing enumeration methods for various operations.