Enumerations on PHP

ID : 1001

viewed : 200

Tags : phpenumerationphp

Top 5 Answer for Enumerations on PHP

vote vote


Depending upon use case, I would normally use something simple like the following:

abstract class DaysOfWeek {     const Sunday = 0;     const Monday = 1;     // etc. }  $today = DaysOfWeek::Sunday; 

However, other use cases may require more validation of constants and values. Based on the comments below about reflection, and a few other notes, here's an expanded example which may better serve a much wider range of cases:

abstract class BasicEnum {     private static $constCacheArray = NULL;      private static function getConstants() {         if (self::$constCacheArray == NULL) {             self::$constCacheArray = [];         }         $calledClass = get_called_class();         if (!array_key_exists($calledClass, self::$constCacheArray)) {             $reflect = new ReflectionClass($calledClass);             self::$constCacheArray[$calledClass] = $reflect->getConstants();         }         return self::$constCacheArray[$calledClass];     }      public static function isValidName($name, $strict = false) {         $constants = self::getConstants();          if ($strict) {             return array_key_exists($name, $constants);         }          $keys = array_map('strtolower', array_keys($constants));         return in_array(strtolower($name), $keys);     }      public static function isValidValue($value, $strict = true) {         $values = array_values(self::getConstants());         return in_array($value, $values, $strict);     } } 

By creating a simple enum class that extends BasicEnum, you now have the ability to use methods thusly for simple input validation:

abstract class DaysOfWeek extends BasicEnum {     const Sunday = 0;     const Monday = 1;     const Tuesday = 2;     const Wednesday = 3;     const Thursday = 4;     const Friday = 5;     const Saturday = 6; }  DaysOfWeek::isValidName('Humpday');                  // false DaysOfWeek::isValidName('Monday');                   // true DaysOfWeek::isValidName('monday');                   // true DaysOfWeek::isValidName('monday', $strict = true);   // false DaysOfWeek::isValidName(0);                          // false  DaysOfWeek::isValidValue(0);                         // true DaysOfWeek::isValidValue(5);                         // true DaysOfWeek::isValidValue(7);                         // false DaysOfWeek::isValidValue('Friday');                  // false 

As a side note, any time I use reflection at least once on a static/const class where the data won't change (such as in an enum), I cache the results of those reflection calls, since using fresh reflection objects each time will eventually have a noticeable performance impact (Stored in an assocciative array for multiple enums).

Now that most people have finally upgraded to at least 5.3, and SplEnum is available, that is certainly a viable option as well--as long as you don't mind the traditionally unintuitive notion of having actual enum instantiations throughout your codebase. In the above example, BasicEnum and DaysOfWeek cannot be instantiated at all, nor should they be.

vote vote


There is a native extension, too. The SplEnum

SplEnum gives the ability to emulate and create enumeration objects natively in PHP.




The PECL extension is not bundled with PHP.

A DLL for this PECL extension is currently unavailable.

vote vote


From PHP 8.1, you can use native enumerations.

The basic syntax looks like this:

enum TransportMode {   case Bicycle;   case Car;   case Ship;   case Plane;   case Feet; } 
function travelCost(TransportMode $mode, int $distance): int { /* implementation */ }   $mode = TransportMode::Boat;  $bikeCost = travelCost(TransportMode::Bicycle, 90); $boatCost = travelCost($mode, 90);  // this one would fail: (Enums are singletons, not scalars) $failCost = travelCost('Car', 90); 


By default, enumerations are not backed by any kind of scalar. So TransportMode::Bicycle is not 0, and you cannot compare using > or < between enumerations.

But the following works:

$foo = TransportMode::Car; $bar = TransportMode::Car; $baz = TransportMode::Bicycle;  $foo === $bar; // true $bar === $baz; // false  $foo instanceof TransportMode; // true  $foo > $bar || $foo <  $bar; // false either way 

Backed Enumerations

You can also have "backed" enums, where each enumeration case is "backed" by either an int or a string.

enum Metal: int {   case Gold = 1932;   case Silver = 1049;   case Lead = 1134;   case Uranium = 1905;   case Copper = 894; } 
  • If one case has a backed value, all cases need to have a backed value, there are no auto-generated values.
  • Notice the type of the backed value is declared right after the enumeration name
  • Backed values are read only
  • Scalar values need to be unique
  • Values need to be literals or literal expressions
  • To read the backed value you access the value property: Metal::Gold->value.

Finally, backed enumerations implement a BackedEnum interface internally, which exposes two methods:

  • from(int|string): self
  • tryFrom(int|string): ?self

They are almost equivalent, with the important distinction that the first one will throw an exception if the value is not found, and the second will simply return null.

// usage example:  $metal_1 = Metal::tryFrom(1932); // $metal_1 === Metal::Gold; $metal_2 = Metal::tryFrom(1000); // $metal_2 === null;  $metal_3 = Metal::from(9999); // throws Exception 


Enumerations may have methods, and thus implement interfaces.

interface TravelCapable {     public function travelCost(int $distance): int;     public function requiresFuel(): bool; }  enum TransportMode: int implements TravelCapable{   case Bicycle = 10;   case Car = 1000 ;   case Ship = 800 ;   case Plane = 2000;   case Feet = 5;      public function travelCost(int $distance): int   {     return $this->value * $distance;   }      public function requiresFuel(): bool {     return match($this) {         TransportMode::Car, TransportMode::Ship, TransportMode::Plane => true,       TransportMode::Bicycle, TransportMode::Feet => false     }   } }  $mode = TransportMode::Car;  $carConsumesFuel = $mode->requiresFuel();   // true $carTravelCost   = $mode->travelCost(800);  // 800000 

Value listing

Both Pure Enums and Backed Enums internally implement the interface UnitEnum, which includes the (static) method UnitEnum::cases(), and allows to retrieve an array of the cases defined in the enumeration:

$modes = TransportMode::cases(); 

And now $modes is:

[     TransportMode::Bicycle,     TransportMode::Car,     TransportMode::Ship,     TransportMode::Plane     TransportMode::Feet ] 

Static methods

Enumerations can implement their own static methods, which would generally be used for specialized constructors.

This covers the basics. To get the whole thing, head on to the relevant RFC until the feature is released and published in PHPs documentation.

vote vote


What about class constants?

<?php  class YourClass {     const SOME_CONSTANT = 1;      public function echoConstant()     {         echo self::SOME_CONSTANT;     } }  echo YourClass::SOME_CONSTANT;  $c = new YourClass; $c->echoConstant(); 
vote vote


The top answer above is fantastic. However, if you extend it in two different ways, then whichever extension is done first results in a call to the functions will create the cache. This cache will then be used by all subsequent calls, no matter whichever extension the calls are initiated by ...

To solve this, replace the variable and first function with:

private static $constCacheArray = null;  private static function getConstants() {     if (self::$constCacheArray === null) self::$constCacheArray = array();      $calledClass = get_called_class();     if (!array_key_exists($calledClass, self::$constCacheArray)) {         $reflect = new \ReflectionClass($calledClass);         self::$constCacheArray[$calledClass] = $reflect->getConstants();     }      return self::$constCacheArray[$calledClass]; } 

Top 3 video Explaining Enumerations on PHP