Introduction to PHP Enums
Tags: php, webdev, programming
Published: 2022-07-03 10:02:00


PHP `8.1` finally brings enums which can be know from other programming languages like `C#`. It is in my opinion one of best things which came with new php version.

## Enums

Prior enums you maybe used static classes like me or you have installed enum composer package. Enums can be defined with word `enum` instead of `class` following with enum name. Values are defined witch word `case` following name of value. Enum defined as bellow returns for each value it's number in order from 1.

```php
enum DocumentType
{
    case order; //1
    case invoice; //2
    case orderItem; //3
}
```

then using is obvious

```php
DocumentType::order //enum(DocumentType::order)
```

reutrn type of each case is `enum(DocumentType::<case-name>)`. If you vant to get value of case you have to add `value` keyword to you call

```php
DocumentType::order->value //1
```

You can also get enum from value as bellow

```php
DocumentType::from(2) //enum(DocumentType::order)
```

if you try to pass to `from()` something that not exist in your enum it will throw `\ValueError` whic can be easily handled with `try catch`. 

## Backed enums

Tere are something called "backed enums" which are basically same as standard enums but you can define for each enum value (property) value and type which you like, for example

```php
enum DocumentType: string
{
    case order = 'application/disclosure.document.order';
    case invoice = 'application/disclosure.document.invoice';
    case orderItem = 'application/disclosure.document.order-item';
}
```

Using is same as with normal enums but as return of value you get string that you defined instad of order number. For example:

```php
DocumentType::order->value //application/disclosure.document.order
```

## Using with other classes

As i said prior enums I used static classes with some defined properties like one bellow

```php
class ImportDocumentType
{
    public static string $order = "application/disclosure.document.order";

    public static string $orderItem = "application/disclosure.document.order-item";

    public static string $invoice = "application/disclosure.document.invoice";

    public static function get(string $property): string
    {
        if (property_exists(self::class, $property)) {
            return self::$$property;
        } else {
            throw new \InvalidArgumentException("Property $property does not exist in class " . self::class);
        }
    }
}
```

It is much more text as you can see and it not ideal (but as example its enough). Than in class you can use it as bellow. (i use interfaces because it's simpler)

```php
interface Document
{
    protected string $type;

    public function __construct(string $type);

    public function getType(): string;
}
```

Calling `ImportDocumentType::$order` has return type of `string` and returns just value of that variable. So as you can see `__construct()` of my class accepts any string which is not ideal, because you can put there anything. `getType()` function simmilary returns just string that you put there - which don't have to be just `ImportDocumentType`. 

As someone who really love to use typed properties (not just in PHP but in other languages too), because code looks much more clean and you still know what you get in return when calling your functions, I can agree with people who tells that the PHP code is a mess. It was and I almost ditch PHP just for that, but with new version it is a lot better.

Back to my class, with enums it can looks like one bellow

```php
interface Document
{
    protected DocumentType $type;

    public function __construct(DocumentType $type);

    public function getType(): DocumentType;
}
```

It is much better isnt it? And I know that `$type` in `__construct()` can only be `DocumentType` and nothing else. Simmilar it is when you calling `getType()` and you know you can only get `DocumentType`.

## In the end

As you can see using enums is easy (you don't need to define our functions), using enums ensure that variable can be only enum and not any other string as from my example above.

Do you like new additions in PHP? I love them and I am excited what will brings us new versions of it.

Originally posted at [My Blog](https://www.maymeow.blog/introduction-to-php-enums/)

Photo by <a href="https://unsplash.com/@crissyjarvis?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Crissy Jarvis</a> on <a href="https://unsplash.com/s/photos/counting?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>

- GitHub: https://github.com/MayMeow
- DEV: https://dev.to/maymeow
- Hashnode: https://hashnode.com/@maymeow
- Ko-fi: https://ko-fi.com/maymeow