Enumerations on PHP

Question

I know that PHP doesn t yet have native Enumerations  But I have become accustomed to them from the Java world  I would love to use enums as a way to give predefined values which IDEs  auto-completion features could understand  Constants do the trick  but there s the namespace collision problem and  or actually because  they re global  Arrays don t have the namespace problem  but they re too vague  they can be overwritten at runtime and IDEs rarely know how to autofill their keys without additional static analysis annotations or attributes  Are there any solutions workarounds you commonly use  Does anyone recall whether the PHP guys have had any thoughts or decisions around enumerations

User · Answer

class DayOfWeek       static  values   array          self  MONDAY          self  TUESDAY                             const MONDAY    0      const TUESDAY   1                 today   DayOfWeek  MONDAY      If you want to check if a value is valid assert  in array   today  DayOfWeek   values        Don t use reflection  It makes it extremely difficult to reason about your code and track down where something is being used  and tends to break static analysis tools  eg what s built into your IDE

User · Answer

I know this is an old thread  however none of the workarounds I ve seen really looked like enums  since almost all workarounds requires you to manually assign values to the enum items  or it requires you to pass an array of enum keys to a function  So I created my own solution for this    To create an enum class using my solution one can simply extend this Enum class below  create a bunch of static variables  no need to initialize them   and make a call to yourEnumClass  init   just below the definition of your enum class    edit  This only works in php    5 3  but it can probably be modified to work in older versions as well              A base class for enums          This class can be used as a base class for enums      It can be used to create regular enums  incremental indices   but it can also be used to create binary flag values     To create an enum class you can simply extend this class  and make a call to  lt yourEnumClass gt   init   before you use the enum     Preferably this call is made directly after the class declaration      Example usages     DaysOfTheWeek class php    abstract class DaysOfTheWeek extends Enum          static  MONDAY   1          static  TUESDAY          static  WEDNESDAY          static  THURSDAY          static  FRIDAY          static  SATURDAY          static  SUNDAY          DaysOfTheWeek  init           example php    require once  DaysOfTheWeek class php        today   date  N       if   today    DaysOfTheWeek   SUNDAY     today    DaysOfTheWeek   SATURDAY          echo  It s weekend           Flags class php    abstract class Flags extends Enum          static  FLAG 1          static  FLAG 2          static  FLAG 3          Flags  init Enum   BINARY FLAG          example2 php    require once  Flags class php        flags   Flags   FLAG 1   Flags   FLAG 2     if   flags  amp  Flags   FLAG 1          echo  Flag 1 is set           author Tiddo Langerak     abstract class Enum       static  BINARY FLAG   1                 This function must be called to initialize the enumeration                  param bool  flags If the USE BINARY flag is provided  the enum values will be binary flag values  Default  no flags set               public static function init  flags   0             First  we want to get a list of all static properties of the enum class  We ll use the ReflectionClass for this           enum   get called class             ref   new ReflectionClass  enum            items    ref- gt getStaticProperties              Now we can start assigning values to the items           if   flags  amp  self   BINARY FLAG                 If we want binary flag values  our first value should be 1               value   1                Now we can set the values for all items              foreach   items as  key  gt  item                   if   isset  item                                           If no value is set manually  we should set it                       enum    key    value                        And we need to calculate the new value                      value    2                    else                         If there was already a value set  we will continue starting from that value  but only if that was a valid binary flag value                        Otherwise  we will just skip this item                      if   key    0  amp  amp    key  amp    key - 1     0                            value   2    item                                            else                 If we want to use regular indices  we ll start with index 0               value   0                Now we can set the values for all items              foreach   items as  key  gt  item                   if   isset  item                          If no value is set manually  we should set it  and increment the value for the next item                       enum    key    value                       value                      else                         If a value was already set  we ll continue from that value                       value    item 1

User · Answer

One of the aspects missing from some of the other answers here is a way to use enums with type hinting   If you define your enum as a set of constants in an abstract class  e g   abstract class ShirtSize       public const SMALL   1      public const MEDIUM   2      public const LARGE   3      then you can t type hint it in a function parameter - for one  because it s not instantiable  but also because the type of ShirtSize  SMALL is int  not ShirtSize   That s why native enums in PHP would be so much better than anything we can come up with  However  we can approximate an enum by keeping a private property which represents the value of the enum  and then restricting the initialization of this property to our predefined constants  To prevent the enum from being instantiated arbitrarily  without the overhead of type-checking a whitelist   we make the constructor private   class ShirtSize       private  size      private function   construct   size             this- gt size    size            public function equals  ShirtSize  s            return  this- gt size      s- gt size            public static function SMALL      return new self 1         public static function MEDIUM      return new self 2         public static function LARGE      return new self 3         Then we can use ShirtSize like this   function sizeIsAvailable   productId  ShirtSize  size           business magic   if sizeIsAvailable   GET  id    ShirtSize  LARGE           echo  Available     else       echo  Out of stock       s2   ShirtSize  SMALL     s3   ShirtSize  MEDIUM    echo  s2- gt equals  s3     SMALL    MEDIUM     SMALL    MEDIUM     This way  the biggest difference from the user s perspective is that you have to tack on a    on the constant s name   One downside though is that      which compares object equality  will return false when    returns true  For that reason  it s best to provide an equals method  so that users don t have to remember to use    and not     to compare two enum values   EDIT  A couple of the existing answers are very similar  particularly  https   stackoverflow com a 25526473 2407870

User · Answer

Finally  A PHP 7 1  answer with constants that cannot be overridden          An interface that groups HTTP Accept  header Media Types in one place      interface MediaTypes                 Now  if you have to use these same constants with another class  you can       without creating funky inheritance   is-a relationships        Also  this gets around the single inheritance limitation              public const HTML    text html       public const JSON    application json       public const XML    application xml       public const TEXT    text plain             An generic request class      abstract class Request          Why not put the constants here         1  The logical reuse issue         2  Single Inheritance          3  Overriding is possible          Why put class constants here         1  The constant value will not be necessary in other class families            An incoming   server-side HTTP request class      class HttpRequest extends Request implements MediaTypes          This class can implement groups of constants as necessary      If you are using namespaces  code completion should work   However  in doing this  you loose the ability to hide the constants within the class family  protected  or class alone  private   By definition  everything in an Interface is public   PHP Manual  Interfaces

User · Answer

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- gt 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

User · Answer

Stepping on the answer of  Brian Cline I thought I might give my 5 cents   lt  php         A class that simulates Enums behaviour     lt code gt     class Season extends Enum        const Spring    0        const Summer   1        const Autumn   2        const Winter   3               currentSeason   new Season Season  Spring       nextYearSeason   new Season Season  Spring       winter   new Season Season  Winter       whatever   new Season -1                    Throws InvalidArgumentException    echo  currentSeason is Season  Spring        True    echo  currentSeason getName                   Spring     echo  currentSeason is  nextYearSeason       True    echo  currentSeason is Season  Winter        False    echo  currentSeason is Season  Spring        True    echo  currentSeason is  winter               False     lt  code gt         Class Enum        PHP Version 5 5     abstract class Enum                  Will contain all the constants of every enum that gets created to         avoid expensive ReflectionClass usage         var array             private static   constCacheArray                      The value that separates this instance from the rest of the same class         var mixed             private   value                 The label of the Enum instance  Will take the string name of the         constant provided  used for logging and human readable messages         var string             private   name                 Creates an enum instance  while makes sure that the value given to the         enum is a valid one                 param mixed  value The value of the current                 throws  InvalidArgumentException             public final function   construct  value                 constants   self   getConstants            if  count  constants      count array unique  constants                  throw new  InvalidArgumentException  Enums cannot contain duplicate constant values                      if   name   array search  value   constants                  this- gt  value    value               this- gt  name    name            else               throw new  InvalidArgumentException  Invalid enum value provided                                   Returns the constant name of the current enum instance                 return string             public function getName                 return  this- gt  name                       Returns the value of the current enum instance                 return mixed             public function getValue                 return  this- gt  value                       Checks whether this enum instance matches with the provided one         This function should be used to compare Enums at all times instead        of an identity comparison          lt code gt            Assuming EnumObject and EnumObject2 both extend the Enum class           and constants with such values are defined         var    new EnumObject  test             var2   new EnumObject  test            var3   new EnumObject2  test            var4   new EnumObject2  test2           echo  var- gt is  var2       true        echo  var- gt is  test       true        echo  var- gt is  var3       false        echo  var3- gt is  var4      false         lt  code gt                  param mixed Enum  enum The value we are comparing this enum object against                                If the value is instance of the Enum class makes                                sure they are instances of the same class as well                                  otherwise just ensures they have the same value                 return bool             public final function is  enum                   If we are comparing enums  just make            sure they have the same toString value         if  is subclass of  enum    CLASS                   return get class  this      get class  enum                        amp  amp   this- gt getValue        enum- gt getValue              else                  Otherwise assume  enum is the value we are comparing against                and do an exact comparison             return  this- gt getValue        enum                                     Returns the constants that are set for the current Enum instance                 return array             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- gt getConstants                      return self    constCacheArray  calledClass

User · Answer

There is a native extension  too  The SplEnum     SplEnum gives the ability to emulate and create enumeration objects   natively in PHP    http   www php net manual en class splenum php  Attention   https   www php net manual en spl-types installation php     The PECL extension is not bundled with PHP       A DLL for this PECL extension is currently unavailable

User · Answer

I have recently developed a simple library for PHP Enums  https   github com dnl-blkv simple-php-enum  At the moment of writing this answer  it is still in pre-release stage  but already fully-functional  well-documented and published on Packagist   This might be a handy option if you are looking for easy-to-implement enums similar to those of C C

User · Answer

The most common solution that I have seen to enum s in PHP has been to create a generic enum class and then extend it  You might take a look at this   UPDATE  Alternatively  I found this from phpclasses org

User · Answer

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- gt getConstants               return self   constCacheArray  calledClass

User · Answer

My attempt to create an enum with PHP   it s extremely limited since it doesn t support objects as the enum values but still somewhat useful     class ProtocolsEnum        const HTTP    1       const HTTPS    2       const FTP    3                   Retrieve an enum value         param string  name         return string             public static function getValueByName  name            return constant  self      name                          Retrieve an enum key name         param string  code         return string             public static function getNameByValue  code            foreach get class constants   as  key   gt   val                if  val     code                    return  key                                                Retrieve associate array of all constants  used for creating droplist options          return multitype              public static function toArray                   return array flip self  get class constants                private static function get class constants                  reflect   new ReflectionClass   CLASS             return  reflect- gt getConstants

User · Answer

This is my take on  dynamic  enum    so that i can call it with variables  ex  from a form   look at updated verison below this codeblock      value    concert    Enumvalue   EnumCategory  enum  value      EnumValue   1  class EnumCategory      const concert   1      const festival   2      const sport   3      const nightlife   4      const theatre   5      const musical   6      const cinema   7      const charity   8      const museum   9      const other   10       public function enum  string           return constant  EnumCategory     string             UPDATE  Better way of doing it     class EnumCategory        static  concert   1      static  festival   2      static  sport   3      static  nightlife   4      static  theatre   5      static  musical   6      static  cinema   7      static  charity   8      static  museum   9      static  other   10       Call with  EnumCategory     category

User · Answer

Some good solutions on here  Here s my version   It s strongly typed It works with IDE auto-completion Enums are defined by a code and a description  where the code can be an integer  a binary value  a short string  or basically anything else you want   The pattern could easily be extended to support orther properties  It asupports value      and reference       comparisons and works in switch statements   I think the main disadvantage is that enum members do have to be separately declared and instantiated  due to the descriptions and PHP s inability to construct objects at static member declaration time   I guess a way round this might be to use reflection with parsed doc comments instead  The abstract enum looks like this   lt  php  abstract class AbstractEnum            var array cache of all enum instances by class name and integer value        private static  allEnumMembers   array              var mixed        private  code            var string        private  description                  Return an enum instance of the concrete type on which this static method is called  assuming an instance        exists for the passed in value   Otherwise an exception is thrown                 param  code         return AbstractEnum         throws Exception             public static function getByCode  code                 concreteMembers    amp self  getConcreteMembers             if  array key exists  code   concreteMembers                 return  concreteMembers  code                      throw new Exception  quot Value   code  does not exist for enum   quot  get called class    quot   quot               public static function getAllMembers                 return self  getConcreteMembers                          Create  cache and return an instance of the concrete enum type for the supplied primitive value                 param mixed  code code to uniquely identify this enum         param string  description         throws Exception         return AbstractEnum             protected static function enum  code   description                 concreteMembers    amp self  getConcreteMembers             if  array key exists  code   concreteMembers                 throw new Exception  quot Value   code  has already been added to enum   quot  get called class    quot   quot                        concreteMembers  code     concreteEnumInstance   new static  code   description            return  concreteEnumInstance                         return AbstractEnum               private static function  amp getConcreteMembers              thisClassName   get called class             if   array key exists  thisClassName  self   allEnumMembers                  concreteMembers   array                self   allEnumMembers  thisClassName     concreteMembers                     return self   allEnumMembers  thisClassName              private function   construct  code   description                 this- gt code    code           this- gt description    description             public function getCode                 return  this- gt code             public function getDescription                 return  this- gt description           Here s an example concrete enum   lt  php  require  AbstractEnum php     class EMyEnum extends AbstractEnum            var EMyEnum        public static  MY FIRST VALUE           var EMyEnum        public static  MY SECOND VALUE           var EMyEnum        public static  MY THIRD VALUE       public static function  init                 self   MY FIRST VALUE   self  enum 1   My first value            self   MY SECOND VALUE   self  enum 2   My second value            self   MY THIRD VALUE   self  enum 3   My third value             EMyEnum   init     Which can be used like this   lt  php  require  EMyEnum php     echo EMyEnum   MY FIRST VALUE- gt getCode         EMyEnum   MY FIRST VALUE- gt getDescription   PHP EOL PHP EOL   var dump EMyEnum  getAllMembers      echo PHP EOL EMyEnum  getByCode 2 - gt getDescription   PHP EOL   And produces this output   1   My first value array 3         1   gt      object EMyEnum  1  2            quot code quot   quot AbstractEnum quot  private   gt        int 1          quot description quot   quot AbstractEnum quot  private   gt        string 14   quot My first value quot             2   gt      object EMyEnum  2  2            quot code quot   quot AbstractEnum quot  private   gt        int 2          quot description quot   quot AbstractEnum quot  private   gt        string 15   quot My second value quot             3   gt      object EMyEnum  3  2            quot code quot   quot AbstractEnum quot  private   gt        int 3          quot description quot   quot AbstractEnum quot  private   gt        string 14   quot My third value quot             My second value

User · Answer

I used classes with constants   class Enum       const NAME          aaaa       const SOME VALUE    bbbb      print Enum  NAME

User · Answer

abstract class Enumeration       public static function enum                   reflect   new ReflectionClass  get called class              return  reflect- gt getConstants              class Test extends Enumeration       const A    a       const B    b           foreach  Test  enum   as  key   gt   value        echo   key - gt   value lt br gt

User · Answer

The most common solution that I have seen to enum s in PHP has been to create a generic enum class and then extend it  You might take a look at this   UPDATE  Alternatively  I found this from phpclasses org

User · Answer

I like enums from java too and for this reason I write my enums in this way  I think this is the most similiar behawior like in Java enums  of course  if some want to use more methods from java should write it here  or in abstract class but core idea is embedded in code below   class FruitsEnum        static  APPLE   null      static  ORANGE   null       private  value   null       public static  map       public function   construct  value             this- value    value             public static function init              self   APPLE    new FruitsEnum  Apple            self   ORANGE   new FruitsEnum  Orange              static map to get object by name - example Enum  get  INIT   - returns Enum   INIT object          self   map   array                Apple     self   APPLE               Orange     self   ORANGE                       public static function get  element            if  element    null              return null          return self   map  element              public function getValue             return  this- value             public function equals FruitsEnum  element            return  element- getValue       this- getValue               public function   toString              return  this- value          FruitsEnum  init     var dump FruitsEnum   APPLE- equals FruitsEnum   APPLE      true var dump FruitsEnum   APPLE- equals FruitsEnum   ORANGE      false var dump FruitsEnum   APPLE instanceof FruitsEnum     true var dump FruitsEnum  get  Apple  - equals FruitsEnum   APPLE      true - enum from string var dump FruitsEnum  get  Apple  - equals FruitsEnum  get  Orange        false

User · Answer

Now you can use The SplEnum class to build it natively  As per the official documentation      SplEnum gives the ability to emulate and create enumeration objects   natively in PHP     lt  php class Month extends SplEnum       const   default   self  January       const January   1      const February   2      const March   3      const April   4      const May   5      const June   6      const July   7      const August   8      const September   9      const October   10      const November   11      const December   12     echo new Month Month  June    PHP EOL   try       new Month 13     catch  UnexpectedValueException  uve        echo  uve- gt getMessage     PHP EOL      gt    Please note  it s an extension which has to be installed  but not available by default  Which comes under Special Types described in the php website itself  The above example is taken from the PHP site

User · Answer

I ve commented on some of the other answers here  so I figured I would weigh in too  At the end of the day  since PHP doesn t support typed enumerations  you can go one of two ways  hack out typed enumerations  or live with the fact that they re extremely difficult to hack out effectively   I prefer to live with the fact  and instead use the const method that other answers here have used in some way or another   abstract class Enum        const NONE   null       final private function   construct                 throw new NotSupportedException                   final private function   clone                 throw new NotSupportedException               final public static function toArray                 return  new ReflectionClass static  class  - gt getConstants               final public static function isValid  value                return in array  value  static  toArray                An example enumeration   final class ResponseStatusCode extends Enum        const OK                           200      const CREATED                      201      const ACCEPTED                     202                 const SERVICE UNAVAILABLE          503      const GATEWAY TIME OUT             504      const HTTP VERSION NOT SUPPORTED   505       Using Enum as a base class from which all other enumerations extend allows for helper methods  such as toArray  isValid  and so on  To me  typed enumerations  and managing their instances  just end up too messy     Hypothetical  If  there existed a   getStatic magic method  and preferably an   equals magic method too  much of this could be mitigated with a sort of multiton pattern    The following is hypothetical  it won t work  though perhaps one day it will   final class TestEnum        private static   values              FOO    gt  1           BAR    gt  2           QUX    gt  3             private static   instances            public static function   getStatic  name                if  isset static    values  name                          if  empty static    instances  name                                  static    instances  name    new static  name                             return static    instances  name                     throw new Exception sprintf  Invalid enumeration value    s     name               private   value       public function   construct  name                 this- gt  value   static    values  name              public function   equals  object                if   object instanceof static                        return  object- gt  value      this- gt  value                    return  object      this- gt  value             foo   TestEnum   FOO     object TestEnum  1  1                                   value   TestEnum  private   gt                              int 1                                zap   TestEnum   ZAP     Uncaught exception  Exception  with message                            Invalid enumeration member   ZAP     qux   TestEnum   QUX  TestEnum   QUX     qux     true  hello world       qux     false

User · Answer

I ve commented on some of the other answers here  so I figured I would weigh in too  At the end of the day  since PHP doesn t support typed enumerations  you can go one of two ways  hack out typed enumerations  or live with the fact that they re extremely difficult to hack out effectively   I prefer to live with the fact  and instead use the const method that other answers here have used in some way or another   abstract class Enum        const NONE   null       final private function   construct                 throw new NotSupportedException                   final private function   clone                 throw new NotSupportedException               final public static function toArray                 return  new ReflectionClass static  class  - gt getConstants               final public static function isValid  value                return in array  value  static  toArray                An example enumeration   final class ResponseStatusCode extends Enum        const OK                           200      const CREATED                      201      const ACCEPTED                     202                 const SERVICE UNAVAILABLE          503      const GATEWAY TIME OUT             504      const HTTP VERSION NOT SUPPORTED   505       Using Enum as a base class from which all other enumerations extend allows for helper methods  such as toArray  isValid  and so on  To me  typed enumerations  and managing their instances  just end up too messy     Hypothetical  If  there existed a   getStatic magic method  and preferably an   equals magic method too  much of this could be mitigated with a sort of multiton pattern    The following is hypothetical  it won t work  though perhaps one day it will   final class TestEnum        private static   values              FOO    gt  1           BAR    gt  2           QUX    gt  3             private static   instances            public static function   getStatic  name                if  isset static    values  name                          if  empty static    instances  name                                  static    instances  name    new static  name                             return static    instances  name                     throw new Exception sprintf  Invalid enumeration value    s     name               private   value       public function   construct  name                 this- gt  value   static    values  name              public function   equals  object                if   object instanceof static                        return  object- gt  value      this- gt  value                    return  object      this- gt  value             foo   TestEnum   FOO     object TestEnum  1  1                                   value   TestEnum  private   gt                              int 1                                zap   TestEnum   ZAP     Uncaught exception  Exception  with message                            Invalid enumeration member   ZAP     qux   TestEnum   QUX  TestEnum   QUX     qux     true  hello world       qux     false

User · Answer

I found this library on github and I think it provides a very decent alternative to the answers here   PHP Enum implementation inspired from SplEnum   You can type-hint  function setAction Action  action    You can enrich the enum with methods  e g  format  parse       You can extend the enum to add new values  make your enum final to prevent it  You can get a list of all the possible values  see below    Declaration   lt  php use MyCLabs Enum Enum          Action enum     class Action extends Enum       const VIEW    view       const EDIT    edit       Usage   lt  php  action   new Action Action  VIEW       or  action   Action  VIEW      type-hint enum values    lt  php function setAction Action  action

User · Answer

I have taken to using the approach below as it gives me the ability to have type safety for function parameters  auto complete in NetBeans and good performance   The one thing I don t like too much is that you have to call  extended class name   enumerate    after defining the class   abstract class Enum        private   value       protected function   construct  value             this- gt  value    value             public function   toString             return  string   this- gt  value             public static function enumerate              class   get called class             ref   new ReflectionClass  class            statics    ref- gt getStaticProperties            foreach   statics as  name   gt   value                 ref- gt setStaticPropertyValue  name  new  class  value                       class DaysOfWeek extends Enum       public static  MONDAY   0      public static  SUNDAY   1         etc    DaysOfWeek  enumerate     function isMonday DaysOfWeek  d        if   d    DaysOfWeek   MONDAY            return true        else           return false            day   DaysOfWeek   MONDAY  echo  isMonday  day     bummer it s monday     Yay  it s not monday

User · Answer

Pointed out solution works well  Clean and smooth   However  if you want strongly typed enumerations  you can use this   class TestEnum extends Enum       public static  TEST1      public static  TEST2    TestEnum  init       Automatically initializes enum values   With an Enum class looking like   class Enum       public static function parse  enum                 class   get called class             vars   get class vars  class           if  array key exists  enum   vars                 return  vars  enum                     return null             public static function init                  className   get called class             consts   get class vars  className           foreach   consts as  constant   gt   value                if  is null  className    constant                      constantValue    constant                   constantValueName    className           constant     VALUE                   if  defined  constantValueName                          constantValue   constant  constantValueName                                      className    constant   new  className  constantValue                                      public function   construct  value                 this- gt value    value            This way  enum values are strongly typed and   TestEnum   TEST1     TestEnum  parse  TEST1      true statement

User · Answer

The most common solution that I have seen to enum s in PHP has been to create a generic enum class and then extend it  You might take a look at this   UPDATE  Alternatively  I found this from phpclasses org

User · Answer

The accepted answer is the way to go and is actually what I am doing for simplicity  Most advantages of enumeration are offered  readable  fast  etc    One concept is missing  however  type safety  In most languages  enumerations are also used to restrict allowed values  Below is an example of how type safety can also be obtained by using private constructors  static instantiation methods and type checking   class DaysOfWeek   const Sunday   0   const Monday   1      etc    private  intVal   private function   construct  intVal       this- gt intVal    intVal         static instantiation methods  public static function MONDAY       return new self self  Monday         etc       function using type checking function printDayOfWeek DaysOfWeek  d     compiler can now use type checking      to something with  d         calling the function is safe  printDayOfWeek DaysOfWeek  MONDAY       We could even go further  using constants in the DaysOfWeek class might lead to misusage  e g  one might mistakenly use it this way   printDayOfWeek DaysOfWeek  Monday     triggers a compiler error    which is wrong  calls integer constant   We can prevent this using private static variables instead of constants   class DaysOfWeeks     private static  monday   1      etc     private  intVal      private constructor   private function   construct  intVal        this- gt intVal    intVal           public instantiation methods   public static function MONDAY        return new self self   monday           etc        convert an instance to its integer value   public function intVal        return  this- gt intVal           Of course  it is not possible to access integer constants  this was actually the purpose   The intVal method allows to convert a DaysOfWeek object to its integer representation   Note that we could even go further by implementing a caching mechanism in instantiation methods to save memory in the case enumerations are extensively used     Hope this will help

User · Answer

The most common solution that I have seen to enum s in PHP has been to create a generic enum class and then extend it  You might take a look at this   UPDATE  Alternatively  I found this from phpclasses org

User · Answer

Stepping on the answer of  Brian Cline I thought I might give my 5 cents   lt  php         A class that simulates Enums behaviour     lt code gt     class Season extends Enum        const Spring    0        const Summer   1        const Autumn   2        const Winter   3               currentSeason   new Season Season  Spring       nextYearSeason   new Season Season  Spring       winter   new Season Season  Winter       whatever   new Season -1                    Throws InvalidArgumentException    echo  currentSeason is Season  Spring        True    echo  currentSeason getName                   Spring     echo  currentSeason is  nextYearSeason       True    echo  currentSeason is Season  Winter        False    echo  currentSeason is Season  Spring        True    echo  currentSeason is  winter               False     lt  code gt         Class Enum        PHP Version 5 5     abstract class Enum                  Will contain all the constants of every enum that gets created to         avoid expensive ReflectionClass usage         var array             private static   constCacheArray                      The value that separates this instance from the rest of the same class         var mixed             private   value                 The label of the Enum instance  Will take the string name of the         constant provided  used for logging and human readable messages         var string             private   name                 Creates an enum instance  while makes sure that the value given to the         enum is a valid one                 param mixed  value The value of the current                 throws  InvalidArgumentException             public final function   construct  value                 constants   self   getConstants            if  count  constants      count array unique  constants                  throw new  InvalidArgumentException  Enums cannot contain duplicate constant values                      if   name   array search  value   constants                  this- gt  value    value               this- gt  name    name            else               throw new  InvalidArgumentException  Invalid enum value provided                                   Returns the constant name of the current enum instance                 return string             public function getName                 return  this- gt  name                       Returns the value of the current enum instance                 return mixed             public function getValue                 return  this- gt  value                       Checks whether this enum instance matches with the provided one         This function should be used to compare Enums at all times instead        of an identity comparison          lt code gt            Assuming EnumObject and EnumObject2 both extend the Enum class           and constants with such values are defined         var    new EnumObject  test             var2   new EnumObject  test            var3   new EnumObject2  test            var4   new EnumObject2  test2           echo  var- gt is  var2       true        echo  var- gt is  test       true        echo  var- gt is  var3       false        echo  var3- gt is  var4      false         lt  code gt                  param mixed Enum  enum The value we are comparing this enum object against                                If the value is instance of the Enum class makes                                sure they are instances of the same class as well                                  otherwise just ensures they have the same value                 return bool             public final function is  enum                   If we are comparing enums  just make            sure they have the same toString value         if  is subclass of  enum    CLASS                   return get class  this      get class  enum                        amp  amp   this- gt getValue        enum- gt getValue              else                  Otherwise assume  enum is the value we are comparing against                and do an exact comparison             return  this- gt getValue        enum                                     Returns the constants that are set for the current Enum instance                 return array             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- gt getConstants                      return self    constCacheArray  calledClass

User · Answer

based on  this gist  a base class for all enum   abstract class Enum       protected  val       protected function   construct  arg             this- gt val    arg             public function   toString             return  this- gt val             public function   set  arg1   arg2            throw new Exception  enum does not have property               public function   get  arg1            throw new Exception  enum does not have property                  not really needed     public function   call  arg1   arg2            throw new Exception  enum does not have method                  not really needed     static public function   callStatic  arg1   arg2            throw new Exception  enum does not have static method              your enum   final class MyEnum extends Enum       static public function val1             return new self  val1               static public function val2             return new self  val2               static public function val3             return new self  val3              test it    a   MyEnum  val1    echo  1 the enum value is   a  n    function consumeMyEnum MyEnum  arg        return  2 the return value is   arg  n      echo consumeMyEnum  a    version   explode      PHP VERSION   if   version 0   gt   7        try           echo consumeMyEnum  val1          catch  TypeError  e            echo  3 passing argument error happens  PHP 7 0 and above  n            echo   a    MyEnum  val1       4 same n     4 different n   echo   a    MyEnum  val2       5 same n     5 different n     b   MyEnum  val1    echo   a     b      6 same n     6 different n   echo   a      b     7 same n     7 different n     c   MyEnum  val2    echo   a     c      8 same n     8 different n   echo   a      c     9 same n     9 different n    switch   c        case MyEnum  val1    echo  10 case of 1st n   break      case MyEnum  val2    echo  11 case of 2nd n   break      case MyEnum  val3    echo  12 case of 3rd n   break     try        a- gt prop   10    catch  Exception  e        echo  13 set property error happens n      try       echo  a- gt prop    catch  Exception  e        echo  14 get property error happens n      try       echo  a- gt meth      catch  Exception  e        echo  15 method call error happens n      try       echo MyEnum  meth      catch  Exception  e        echo  16 static method call error happens n      class Ordinary    echo  a instanceof MyEnum      17 MyEnum instance n       17 not MyEnum instance n   echo  a instanceof Enum        18 Enum instance n         18 not Enum instance n   echo  a instanceof Ordinary    19 Ordinary instance n     19 not Ordinary instance n     try it online  sanbox

User · Answer

Well  for a simple java like enum in php  I use   class SomeTypeName       private static  enum   array 1   gt   Read   2   gt   Write         public function toOrdinal  name            return array search  name  self   enum              public function toString  ordinal            return self   enum  ordinal             And to call it   SomeTypeName  toOrdinal  Read    SomeTypeName  toString 1     But I m a PHP beginner  struggling with the syntax so this might not be the best way  I experimented some with Class Constants  using Reflection to get the constant name from it s value  might be neater

User · Answer

Finally  A PHP 7 1  answer with constants that cannot be overridden          An interface that groups HTTP Accept  header Media Types in one place      interface MediaTypes                 Now  if you have to use these same constants with another class  you can       without creating funky inheritance   is-a relationships        Also  this gets around the single inheritance limitation              public const HTML    text html       public const JSON    application json       public const XML    application xml       public const TEXT    text plain             An generic request class      abstract class Request          Why not put the constants here         1  The logical reuse issue         2  Single Inheritance          3  Overriding is possible          Why put class constants here         1  The constant value will not be necessary in other class families            An incoming   server-side HTTP request class      class HttpRequest extends Request implements MediaTypes          This class can implement groups of constants as necessary      If you are using namespaces  code completion should work   However  in doing this  you loose the ability to hide the constants within the class family  protected  or class alone  private   By definition  everything in an Interface is public   PHP Manual  Interfaces

User · Answer

Yesterday I wrote this class on my blog  I think it s maybe be easy for use in php scripts   final class EnumException extends Exception    abstract class Enum                   var array ReflectionClass             protected static  reflectorInstances   array                                                    -          enum         var array             protected static  enumInstances   array                                               - gt                                -                                                     var array             protected static  foundNameValueLink   array         protected  constName      protected  constValue                                                                                                                                                                                    toString                                                                                   paradm Node             final public static function get  value                                                                                     10            name   self  getName  value           if   name     false              throw new EnumException                                   className   get called class                if   isset self   enumInstances  className   name                           value   constant  className       name               self   enumInstances  className   name    new  className  name   value                      return self   enumInstances  className   name                                                            -                                    return array              final public static function toArray                  classConstantsArray   self  getReflectorInstance  - gt getConstants            foreach   classConstantsArray as  k   gt   v               classConstantsArray  k     string  v          return  classConstantsArray                                                         toArray                                    - gt                   return ReflectionClass             final private static function getReflectorInstance                  className   get called class            if   isset self   reflectorInstances  className                          self   reflectorInstances  className    new ReflectionClass  className                     return self   reflectorInstances  className                                                                       param string  value             final public static function getName  value                 className    string get called class              value    string  value          if   isset self   foundNameValueLink  className   value                           constantName   array search  value  self  toArray    true               self   foundNameValueLink  className   value     constantName                    return self   foundNameValueLink  className   value                                                                                    param string  name             final public static function isExistName  name                 constArray   self  toArray            return isset  constArray  name                                                                                          param string  value             final public static function isExistValue  value                return self  getName  value      false   false   true                 final private function   clone          final private function   construct  name   value                 this- gt constName    name           this- gt constValue    value             final public function   toString                 return  string  this- gt constValue            Usage   class enumWorkType extends Enum           const FULL   0          const SHORT   1

User · Answer

My Enumeration Class class Enum       protected  m actions   array         public function   construct  actions                 this- gt init  actions              public function init  actions                 this- gt m actions   array            for  i   0   i  lt  count  actions      i                         this- gt m actions  actions  i       i   1                define  actions  i     i   1                         public function toString  index                 keys   array keys  this- gt m actions           for  i   0   i  lt  count  keys      i                        if  this- gt m actions  keys  i       index                                return  keys  i                                    return  undefined              public function fromString  str                return  this- gt m actions  str               Enumeration creation  actions   new Enum array  CREATE    READ    UPDATE    DELETE         Examples print  action objects- gt toString DELETE    print  action objects- gt fromString  DELETE      if  action objects- gt fromString   POST  myAction       CREATE        print  CREATE

User · Answer

I used classes with constants   class Enum       const NAME          aaaa       const SOME VALUE    bbbb      print Enum  NAME

User · Answer

From PHP 8 1 onwards  you ll get native enumerations  At its most basic level they ll work like this  enum TransportMode     case Bicycle    case Car    case Ship    case Plane    case Feet     function travelCost Vehicle  vehicle  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    Values By default  enumerations are not backed by any kind of scalar  So TransportMode  Bicycle is not 0   and you cannot compare using  gt  or  lt  between enumerations  But the following would work   foo   TransportMode  Car   bar   TransportMode  Car    foo      bar     true   foo instanceof TransportMode     true   foo  gt   bar     foo  lt    bar     false either way  Backed Enumerations You can also have  quot backed quot  enums  where each enumeration case is  quot backed quot  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 they type of the backed value is declard right after the enumeration name Backed values are read only Scalar values need to unique Values need to be literals or literal expressions To read the backed value you access the value property  Metal  Gold- gt 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  but the first one will throw an exception if the value is not found  and the seccond will simply return null  Methods Enumeratin 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- gt value    distance           public function requiresFuel    bool       return match  this            TransportMode  Car  TransportMode  Ship  TransportMode  Plane   gt  true        TransportMode  Bicycle  TransportMode  Feet   gt  false              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 basic  To get the whole thing  head on to the relevant RFC until the feature is released and published in PHPs documentation

User · Answer

Here is a github library for handling type-safe enumerations in php   This library handle classes generation  classes caching and it implements the Type Safe Enumeration design pattern  with several helper methods for dealing with enums  like retrieving an ordinal for enums sorting  or retrieving a binary value  for enums combinations   The generated code use a plain old php template file  which is also configurable  so you can provide your own template   It is full test covered with phpunit   php-enums on github  feel free to fork   Usage    see usage php  or unit tests for more details    lt  php   require the library require once   DIR       src Enum func php      if you don t have a cache directory  create one  mkdir   DIR       cache    EnumGenerator  setDefaultCachedClassesDir   DIR       cache       Class definition is evaluated on the fly  Enum  FruitsEnum   array  apple     orange     rasberry     bannana        Class definition is cached in the cache directory for later usage  Enum  CachedFruitsEnum   array  apple     orange     rasberry     bannana      my company name space   true    echo  FruitsEnum  APPLE      FruitsEnum  APPLE       var dump FruitsEnum  APPLE      FruitsEnum  APPLE        n    echo  FruitsEnum  APPLE      FruitsEnum  ORANGE       var dump FruitsEnum  APPLE      FruitsEnum  ORANGE        n    echo  FruitsEnum  APPLE   instanceof Enum     var dump FruitsEnum  APPLE   instanceof Enum      n    echo  FruitsEnum  APPLE   instanceof FruitsEnum     var dump FruitsEnum  APPLE   instanceof FruitsEnum      n    echo  - gt getName   n   foreach  FruitsEnum  iterator   as  enum      echo         enum- gt getName       n      echo  - gt getValue   n   foreach  FruitsEnum  iterator   as  enum      echo         enum- gt getValue       n      echo  - gt getOrdinal   n   foreach  CachedFruitsEnum  iterator   as  enum      echo         enum- gt getOrdinal       n      echo  - gt getBinary   n   foreach  CachedFruitsEnum  iterator   as  enum      echo         enum- gt getBinary       n       Output   FruitsEnum  APPLE      FruitsEnum  APPLE    bool true  FruitsEnum  APPLE      FruitsEnum  ORANGE    bool false  FruitsEnum  APPLE   instanceof Enum  bool true  FruitsEnum  APPLE   instanceof FruitsEnum  bool true  - gt getName     APPLE   ORANGE   RASBERRY   BANNANA - gt getValue     apple   orange   rasberry   bannana - gt getValue   when values have been specified   pig   dog   cat   bird - gt getOrdinal     1   2   3   4 - gt getBinary     1   2   4   8

User · Answer

Here is a github library for handling type-safe enumerations in php   This library handle classes generation  classes caching and it implements the Type Safe Enumeration design pattern  with several helper methods for dealing with enums  like retrieving an ordinal for enums sorting  or retrieving a binary value  for enums combinations   The generated code use a plain old php template file  which is also configurable  so you can provide your own template   It is full test covered with phpunit   php-enums on github  feel free to fork   Usage    see usage php  or unit tests for more details    lt  php   require the library require once   DIR       src Enum func php      if you don t have a cache directory  create one  mkdir   DIR       cache    EnumGenerator  setDefaultCachedClassesDir   DIR       cache       Class definition is evaluated on the fly  Enum  FruitsEnum   array  apple     orange     rasberry     bannana        Class definition is cached in the cache directory for later usage  Enum  CachedFruitsEnum   array  apple     orange     rasberry     bannana      my company name space   true    echo  FruitsEnum  APPLE      FruitsEnum  APPLE       var dump FruitsEnum  APPLE      FruitsEnum  APPLE        n    echo  FruitsEnum  APPLE      FruitsEnum  ORANGE       var dump FruitsEnum  APPLE      FruitsEnum  ORANGE        n    echo  FruitsEnum  APPLE   instanceof Enum     var dump FruitsEnum  APPLE   instanceof Enum      n    echo  FruitsEnum  APPLE   instanceof FruitsEnum     var dump FruitsEnum  APPLE   instanceof FruitsEnum      n    echo  - gt getName   n   foreach  FruitsEnum  iterator   as  enum      echo         enum- gt getName       n      echo  - gt getValue   n   foreach  FruitsEnum  iterator   as  enum      echo         enum- gt getValue       n      echo  - gt getOrdinal   n   foreach  CachedFruitsEnum  iterator   as  enum      echo         enum- gt getOrdinal       n      echo  - gt getBinary   n   foreach  CachedFruitsEnum  iterator   as  enum      echo         enum- gt getBinary       n       Output   FruitsEnum  APPLE      FruitsEnum  APPLE    bool true  FruitsEnum  APPLE      FruitsEnum  ORANGE    bool false  FruitsEnum  APPLE   instanceof Enum  bool true  FruitsEnum  APPLE   instanceof FruitsEnum  bool true  - gt getName     APPLE   ORANGE   RASBERRY   BANNANA - gt getValue     apple   orange   rasberry   bannana - gt getValue   when values have been specified   pig   dog   cat   bird - gt getOrdinal     1   2   3   4 - gt getBinary     1   2   4   8

User · Answer

What about class constants    lt  php  class YourClass       const SOME CONSTANT   1       public function echoConstant                 echo self  SOME CONSTANT           echo YourClass  SOME CONSTANT    c   new YourClass   c- gt echoConstant

User · Answer

From PHP 8 1 onwards  you ll get native enumerations  At its most basic level they ll work like this  enum TransportMode     case Bicycle    case Car    case Ship    case Plane    case Feet     function travelCost Vehicle  vehicle  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    Values By default  enumerations are not backed by any kind of scalar  So TransportMode  Bicycle is not 0   and you cannot compare using  gt  or  lt  between enumerations  But the following would work   foo   TransportMode  Car   bar   TransportMode  Car    foo      bar     true   foo instanceof TransportMode     true   foo  gt   bar     foo  lt    bar     false either way  Backed Enumerations You can also have  quot backed quot  enums  where each enumeration case is  quot backed quot  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 they type of the backed value is declard right after the enumeration name Backed values are read only Scalar values need to unique Values need to be literals or literal expressions To read the backed value you access the value property  Metal  Gold- gt 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  but the first one will throw an exception if the value is not found  and the seccond will simply return null  Methods Enumeratin 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- gt value    distance           public function requiresFuel    bool       return match  this            TransportMode  Car  TransportMode  Ship  TransportMode  Plane   gt  true        TransportMode  Bicycle  TransportMode  Feet   gt  false              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 basic  To get the whole thing  head on to the relevant RFC until the feature is released and published in PHPs documentation

User · Answer

I found this library on github and I think it provides a very decent alternative to the answers here   PHP Enum implementation inspired from SplEnum   You can type-hint  function setAction Action  action    You can enrich the enum with methods  e g  format  parse       You can extend the enum to add new values  make your enum final to prevent it  You can get a list of all the possible values  see below    Declaration   lt  php use MyCLabs Enum Enum          Action enum     class Action extends Enum       const VIEW    view       const EDIT    edit       Usage   lt  php  action   new Action Action  VIEW       or  action   Action  VIEW      type-hint enum values    lt  php function setAction Action  action

User · Answer

I have taken to using the approach below as it gives me the ability to have type safety for function parameters  auto complete in NetBeans and good performance   The one thing I don t like too much is that you have to call  extended class name   enumerate    after defining the class   abstract class Enum        private   value       protected function   construct  value             this- gt  value    value             public function   toString             return  string   this- gt  value             public static function enumerate              class   get called class             ref   new ReflectionClass  class            statics    ref- gt getStaticProperties            foreach   statics as  name   gt   value                 ref- gt setStaticPropertyValue  name  new  class  value                       class DaysOfWeek extends Enum       public static  MONDAY   0      public static  SUNDAY   1         etc    DaysOfWeek  enumerate     function isMonday DaysOfWeek  d        if   d    DaysOfWeek   MONDAY            return true        else           return false            day   DaysOfWeek   MONDAY  echo  isMonday  day     bummer it s monday     Yay  it s not monday

User · Answer

A simpler and lighter version that doesn t use reflection   abstract class enum       private function   construct          static function has  const             name   get called class            return defined   name   const              static function value  const             name   get called class            return defined   name   const    constant   name   const     false            Usage   class requestFormat  extends enum   const HTML   1  const JSON   2  const XML    3  const FORM   4     echo requestFormat  value  JSON       2 echo requestFormat  has  JSON         true   This gives the advantage of constants and also allows for checking the validity of them but it lacks other fancy functionality provided by more complex solutions given is this question  the more obvious the inability of checking the reverse of a value  in the example above  you can t check if  2  is a valid value

User · Answer

One of the aspects missing from some of the other answers here is a way to use enums with type hinting   If you define your enum as a set of constants in an abstract class  e g   abstract class ShirtSize       public const SMALL   1      public const MEDIUM   2      public const LARGE   3      then you can t type hint it in a function parameter - for one  because it s not instantiable  but also because the type of ShirtSize  SMALL is int  not ShirtSize   That s why native enums in PHP would be so much better than anything we can come up with  However  we can approximate an enum by keeping a private property which represents the value of the enum  and then restricting the initialization of this property to our predefined constants  To prevent the enum from being instantiated arbitrarily  without the overhead of type-checking a whitelist   we make the constructor private   class ShirtSize       private  size      private function   construct   size             this- gt size    size            public function equals  ShirtSize  s            return  this- gt size      s- gt size            public static function SMALL      return new self 1         public static function MEDIUM      return new self 2         public static function LARGE      return new self 3         Then we can use ShirtSize like this   function sizeIsAvailable   productId  ShirtSize  size           business magic   if sizeIsAvailable   GET  id    ShirtSize  LARGE           echo  Available     else       echo  Out of stock       s2   ShirtSize  SMALL     s3   ShirtSize  MEDIUM    echo  s2- gt equals  s3     SMALL    MEDIUM     SMALL    MEDIUM     This way  the biggest difference from the user s perspective is that you have to tack on a    on the constant s name   One downside though is that      which compares object equality  will return false when    returns true  For that reason  it s best to provide an equals method  so that users don t have to remember to use    and not     to compare two enum values   EDIT  A couple of the existing answers are very similar  particularly  https   stackoverflow com a 25526473 2407870

User · Answer

Four years later I came across this again  My current approach is this as it allows for code completion in the IDE as well as type safety   Base class   abstract class TypedEnum       private static   instancedValues       private   value      private   name       private function   construct  value   name                 this- gt  value    value           this- gt  name    name             private static function  fromGetter  getter   value                 reflectionClass   new ReflectionClass get called class              methods    reflectionClass- gt getMethods ReflectionMethod  IS STATIC   ReflectionMethod  IS PUBLIC                className   get called class             foreach  methods as  method                        if   method- gt class      className                                 enumItem    method- gt invoke null                    if   enumItem instanceof  className  amp  amp   enumItem- gt  getter        value                                        return  enumItem                                                     throw new OutOfRangeException               protected static function  create  value                if  self    instancedValues     null                        self    instancedValues   array                        className   get called class             if   isset self    instancedValues  className                          self    instancedValues  className    array                       if   isset self    instancedValues  className   value                           debugTrace   debug backtrace                 lastCaller   array shift  debugTrace                while   lastCaller  class        className  amp  amp  count  debugTrace   gt  0                                 lastCaller   array shift  debugTrace                              self    instancedValues  className   value    new static  value   lastCaller  function                        return self    instancedValues  className   value              public static function fromValue  value                return self   fromGetter  getValue    value              public static function fromName  value                return self   fromGetter  getName    value              public function getValue                 return  this- gt  value             public function getName                 return  this- gt  name            Example Enum   final class DaysOfWeek extends TypedEnum       public static function Sunday     return self   create 0             public static function Monday     return self   create 1         public static function Tuesday     return self   create 2            public static function Wednesday     return self   create 3         public static function Thursday     return self   create 4           public static function Friday     return self   create 5         public static function Saturday     return self   create 6               Example usage   function saveEvent DaysOfWeek  weekDay   comment           store week day numeric value and comment       myDatabase- gt save  myeventtable           array  weekday id    gt   weekDay- gt getValue            array  comment    gt   comment          call the function  note  DaysOfWeek  Monday   returns an object of type DaysOfWeek saveEvent DaysOfWeek  Monday     some comment      Note that all instances of the same enum entry are the same    monday1   DaysOfWeek  Monday     monday2   DaysOfWeek  Monday     monday1      monday2     true   You can also use it inside of a switch statement   function getGermanWeekDayName DaysOfWeek  weekDay        switch   weekDay                case DaysOfWeek  Monday    return  Montag           case DaysOfWeek  Tuesday    return  Dienstag                      You can also create an enum entry by name or value    monday   DaysOfWeek  fromValue 2    tuesday   DaysOfWeek  fromName  Tuesday      Or you can just get the name  i e  the function name  from an existing enum entry    wednesday   DaysOfWeek  Wednesday   echo  wednesDay- gt getName       Wednesday

User · Answer

Yesterday I wrote this class on my blog  I think it s maybe be easy for use in php scripts   final class EnumException extends Exception    abstract class Enum                   var array ReflectionClass             protected static  reflectorInstances   array                                                    -          enum         var array             protected static  enumInstances   array                                               - gt                                -                                                     var array             protected static  foundNameValueLink   array         protected  constName      protected  constValue                                                                                                                                                                                    toString                                                                                   paradm Node             final public static function get  value                                                                                     10            name   self  getName  value           if   name     false              throw new EnumException                                   className   get called class                if   isset self   enumInstances  className   name                           value   constant  className       name               self   enumInstances  className   name    new  className  name   value                      return self   enumInstances  className   name                                                            -                                    return array              final public static function toArray                  classConstantsArray   self  getReflectorInstance  - gt getConstants            foreach   classConstantsArray as  k   gt   v               classConstantsArray  k     string  v          return  classConstantsArray                                                         toArray                                    - gt                   return ReflectionClass             final private static function getReflectorInstance                  className   get called class            if   isset self   reflectorInstances  className                          self   reflectorInstances  className    new ReflectionClass  className                     return self   reflectorInstances  className                                                                       param string  value             final public static function getName  value                 className    string get called class              value    string  value          if   isset self   foundNameValueLink  className   value                           constantName   array search  value  self  toArray    true               self   foundNameValueLink  className   value     constantName                    return self   foundNameValueLink  className   value                                                                                    param string  name             final public static function isExistName  name                 constArray   self  toArray            return isset  constArray  name                                                                                          param string  value             final public static function isExistValue  value                return self  getName  value      false   false   true                 final private function   clone          final private function   construct  name   value                 this- gt constName    name           this- gt constValue    value             final public function   toString                 return  string  this- gt constValue            Usage   class enumWorkType extends Enum           const FULL   0          const SHORT   1

User · Answer

I realize this is a very-very-very old thread but I had a thought about this and wanted to know what people thought   Notes  I was playing around with this and realized that if I just modified the   call   function that you can get even closer to actual enums   The   call   function handles all unknown function calls   So let s say you want to make three enums RED LIGHT  YELLOW LIGHT  and GREEN LIGHT   You can do so now by just doing the following    c- gt RED LIGHT     c- gt YELLOW LIGHT     c- gt GREEN LIGHT      Once defined all you have to do is to call them again to get the values   echo  c- gt RED LIGHT    echo  c- gt YELLOW LIGHT    echo  c- gt GREEN LIGHT      and you should get 0  1  and 2   Have fun   This is also now up on GitHub   Update   I ve made it so both the   get   and   set   functions are now used   These allow you to not have to call a function unless you want to   Instead  now you can just say    c- gt RED LIGHT   c- gt YELLOW LIGHT   c- gt GREEN LIGHT    For both the creation and getting of the values   Because the variables haven t been defined initially  the   get   function is called  because there isn t a value specified  which sees that the entry in the array hasn t been made   So it makes the entry  assigns it the last value given plus one  1   increments the last value variable  and returns TRUE   If you set the value    c- gt RED LIGHT   85    Then the   set   function is called and the last value is then set to the new value plus one   1    So now we have a fairly good way to do enums and they can be created on the fly    lt  php                                                                                      Class ENUMS           Original code by Mark Manning          Copyrighted  c  2015 by Mark Manning          All rights reserved            This set of code is hereby placed into the free software universe         via the GNU greater license thus placing it under the Copyleft         rules and regulations with the following modifications            1  You may use this work in any other work   Commercial or otherwise          2  You may make as much money as you can with it          3  You owe me nothing except to give me a small blurb somewhere in             your program or maybe have pity on me and donate a dollar to             sim sales paypal com    -        Blurb            PHP Class Enums by Mark Manning  markem-AT-sim1-DOT-us           Used with permission        Notes            VIM formatting   Set tabs to four 4  spaces                                                                                     class enums       private  enums      private  clear flag      private  last value                                                                                          construct    Construction function   Optionally pass in your enums                                                                                   function   construct          this- gt enums   array         this- gt clear flag   false       this- gt last value   0       if  func num args    gt  0            return  this- gt put  func get args                     return true                                                                                         put    Insert one or more enums                                                                                   function put          args   func get args          Did they send us an array of enums      Ex   c- gt put  array   a   gt 0   b   gt 1             OR   c- gt put  array   a    b    c                 if  is array  args 0            Add them all in           foreach   args 0  as  k  gt  v          Don t let them change it once it is set      Remove the IF statement if you want to be able to modify the enums                if   isset  this- gt enums  k            If they sent an array of enums like this   a   b   c      then we have to     change that to be  A   gt    Where     is the current count of the enums                    if  is numeric  k                          this- gt enums  v     this- gt last value                                Else - they sent  a   gt  A    b   gt  B    c   gt  C                           else                            this- gt last value    v   1                           this- gt enums  k     v                                                                            Nope   Did they just sent us one enum            else         Is this just a default declaration      Ex   c- gt put   a                   if  count  args   lt  2          Again - remove the IF statement if you want to be able to change the enums                    if   isset  this- gt enums  args 0                            this- gt enums  args 0      this- gt last value                                No - they sent us a regular enum     Ex   c- gt put   a    This is the first enum                           else         Again - remove the IF statement if you want to be able to change the enums                            if   isset  this- gt enums  args 0                                    this- gt last value    args 1    1                               this- gt enums  args 0      args 1                                                                                                return true                                                                                         get    Get one or more enums                                                                                   function get          num   func num args         args   func get args          Is this an array of enums request   ie   c- gt get array  a   b   c               if  is array  args 0               ary   array            foreach   args 0  as  k  gt  v                 ary  v     this- gt enums  v                          return  ary                  Is it just ONE enum they want   ie   c- gt get  a               else if    num  gt  0   amp  amp    num  lt  2                 return  this- gt enums  args 0                        Is it a list of enums they want   ie   c- gt get   a    b    c                  else if   num  gt  1                 ary   array                foreach   args as  k  gt  v                     ary  v     this- gt enums  v                                  return  ary                      They either sent something funky or nothing at all        return false                                                                                         clear    Clear out the enum array          Optional   Set the flag in the   construct function          After all  ENUMS are supposed to be constant                                                                                   function clear         if   clear flag            unset   this- gt enums             this- gt enums   array                   return true                                                                                           call     In case someone tries to blow up the class                                                                                   function   call   name   arguments         if  isset  this- gt enums  name      return  this- gt enums  name             else if   isset  this- gt enums  name    amp  amp   count  arguments   gt  0                  this- gt last value    arguments 0    1               this- gt enums  name     arguments 0               return true                        else if   isset  this- gt enums  name    amp  amp   count  arguments   lt  1                  this- gt enums  name     this- gt last value                return true                     return false                                                                                           get    Gets the value                                                                                   function   get  name        if  isset  this- gt enums  name      return  this- gt enums  name             else if   isset  this- gt enums  name                   this- gt enums  name     this- gt last value                return true                     return false                                                                                           set     Sets the value                                                                                   function   set   name   value null         if  isset  this- gt enums  name      return false            else if   isset  this- gt enums  name    amp  amp   is null  value                  this- gt last value    value   1               this- gt enums  name     value              return true                        else if   isset  this- gt enums  name    amp  amp  is null  value                  this- gt enums  name     this- gt last value                return true                     return false                                                                                           destruct     Deconstruct the class   Remove the list of enums                                                                                   function   destruct         unset   this- gt enums         this- gt enums   null       return true             Test code        c   new enums         c- gt RED LIGHT 85        c- gt YELLOW LIGHT   23       c- gt GREEN LIGHT        echo  c- gt RED LIGHT     n       echo  c- gt YELLOW LIGHT     n       echo  c- gt GREEN LIGHT     n      gt

User · Answer

There is a native extension  too  The SplEnum     SplEnum gives the ability to emulate and create enumeration objects   natively in PHP    http   www php net manual en class splenum php  Attention   https   www php net manual en spl-types installation php     The PECL extension is not bundled with PHP       A DLL for this PECL extension is currently unavailable

User · Answer

I know this is an old thread  however none of the workarounds I ve seen really looked like enums  since almost all workarounds requires you to manually assign values to the enum items  or it requires you to pass an array of enum keys to a function  So I created my own solution for this    To create an enum class using my solution one can simply extend this Enum class below  create a bunch of static variables  no need to initialize them   and make a call to yourEnumClass  init   just below the definition of your enum class    edit  This only works in php    5 3  but it can probably be modified to work in older versions as well              A base class for enums          This class can be used as a base class for enums      It can be used to create regular enums  incremental indices   but it can also be used to create binary flag values     To create an enum class you can simply extend this class  and make a call to  lt yourEnumClass gt   init   before you use the enum     Preferably this call is made directly after the class declaration      Example usages     DaysOfTheWeek class php    abstract class DaysOfTheWeek extends Enum          static  MONDAY   1          static  TUESDAY          static  WEDNESDAY          static  THURSDAY          static  FRIDAY          static  SATURDAY          static  SUNDAY          DaysOfTheWeek  init           example php    require once  DaysOfTheWeek class php        today   date  N       if   today    DaysOfTheWeek   SUNDAY     today    DaysOfTheWeek   SATURDAY          echo  It s weekend           Flags class php    abstract class Flags extends Enum          static  FLAG 1          static  FLAG 2          static  FLAG 3          Flags  init Enum   BINARY FLAG          example2 php    require once  Flags class php        flags   Flags   FLAG 1   Flags   FLAG 2     if   flags  amp  Flags   FLAG 1          echo  Flag 1 is set           author Tiddo Langerak     abstract class Enum       static  BINARY FLAG   1                 This function must be called to initialize the enumeration                  param bool  flags If the USE BINARY flag is provided  the enum values will be binary flag values  Default  no flags set               public static function init  flags   0             First  we want to get a list of all static properties of the enum class  We ll use the ReflectionClass for this           enum   get called class             ref   new ReflectionClass  enum            items    ref- gt getStaticProperties              Now we can start assigning values to the items           if   flags  amp  self   BINARY FLAG                 If we want binary flag values  our first value should be 1               value   1                Now we can set the values for all items              foreach   items as  key  gt  item                   if   isset  item                                           If no value is set manually  we should set it                       enum    key    value                        And we need to calculate the new value                      value    2                    else                         If there was already a value set  we will continue starting from that value  but only if that was a valid binary flag value                        Otherwise  we will just skip this item                      if   key    0  amp  amp    key  amp    key - 1     0                            value   2    item                                            else                 If we want to use regular indices  we ll start with index 0               value   0                Now we can set the values for all items              foreach   items as  key  gt  item                   if   isset  item                          If no value is set manually  we should set it  and increment the value for the next item                       enum    key    value                       value                      else                         If a value was already set  we ll continue from that value                       value    item 1

User · Answer

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- gt 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

User · Answer

Now you can use The SplEnum class to build it natively  As per the official documentation      SplEnum gives the ability to emulate and create enumeration objects   natively in PHP     lt  php class Month extends SplEnum       const   default   self  January       const January   1      const February   2      const March   3      const April   4      const May   5      const June   6      const July   7      const August   8      const September   9      const October   10      const November   11      const December   12     echo new Month Month  June    PHP EOL   try       new Month 13     catch  UnexpectedValueException  uve        echo  uve- gt getMessage     PHP EOL      gt    Please note  it s an extension which has to be installed  but not available by default  Which comes under Special Types described in the php website itself  The above example is taken from the PHP site

User · Answer

It might be as simple as  enum DaysOfWeek       Sunday      Monday                 in the future   PHP RFC  Enumerated Types

User · Answer

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- gt 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

User · Answer

My Enum class definition below is Strongly typed  and very natural to use and define   Definition   class Fruit extends Enum       static public  APPLE   1      static public  ORANGE   2    Fruit  initialize      Can also be called in autoloader   Switch over Enum   myFruit   Fruit   APPLE   switch   myFruit        case Fruit   APPLE    echo  I like apples n    break      case Fruit   ORANGE   echo  I hate oranges n   break      gt  gt  I like apples   Pass Enum as parameter  Strongly typed       Function only accepts Fruit enums as input    function echoFruit Fruit  fruit        echo  fruit- gt getName         fruit- gt getValue     n          Call function with each Enum value that Fruit has    foreach  Fruit  getList   as  fruit        echoFruit  fruit        Call function with Apple enum echoFruit Fruit   APPLE     Will produce an error  This solution is strongly typed echoFruit 2     gt  gt  APPLE  1  gt  gt  ORANGE  2  gt  gt  APPLE  1  gt  gt  Argument 1 passed to echoFruit   must be an instance of Fruit  integer given   Echo Enum as string  echo  I have an  myFruit n     gt  gt  I have an APPLE   Get Enum by integer   myFruit   Fruit  getByValue 2    echo  Now I have an  myFruit n     gt  gt  Now I have an ORANGE   Get Enum by Name   myFruit   Fruit  getByName  APPLE     echo  But I definitely prefer an  myFruit n n     gt  gt  But I definitely prefer an APPLE   The Enum Class           author Torge Kummerow     class Enum                   Holds the values for each type of Enum             static private  list   array                    Initializes the enum values by replacing the number with an instance of itself        using reflection             static public function initialize              className   get called class             class   new ReflectionClass  className            staticProperties    class- gt getStaticProperties             self   list  className    array             foreach   staticProperties as  propertyName   gt   amp  value                if   propertyName     list                   continue                enum   new  className  propertyName   value                class- gt setStaticPropertyValue  propertyName   enum               self   list  className   propertyName     enum            unset  value                          Gets the enum for the given value                param integer  value         throws Exception                return Enum             static public function getByValue  value             className   get called class            foreach  self   list  className  as  propertyName  gt  amp  enum                    var  enum Enum                if   enum- gt value     value                  return  enum            unset  enum            throw new Exception  No such enum with value  value of type   get called class                           Gets the enum for the given name                param string  name         throws Exception                return Enum             static public function getByName  name             className   get called class            if  array key exists  name  static   list  className                return self   list  className   name            throw new Exception  No such enum   get called class         name                           Returns the list of all enum variants         return Array of Enum             static public function getList              className   get called class            return self   list  className               private  name      private  value       public function   construct  name   value             this- gt name    name           this- gt value    value             public function   toString             return  this- gt name             public function getValue             return  this- gt value             public function getName             return  this- gt name             Addition  You can ofcourse also add comments for IDEs  class Fruit extends Enum                   This comment is for autocomplete support in common IDEs         var Fruit A yummy apple             static public  APPLE   1                  This comment is for autocomplete support in common IDEs         var Fruit A sour orange             static public  ORANGE   2       This can also go to the autoloader if available  Fruit  initialize

User · Answer

If you want type safety and a bunch of constants that match that type  one way to go is to have an abstract class for your enum and then extend that class with a locked constructor  like so   abstract class DaysOfWeekEnum      public function   construct string  value            this- gt value    value             public function   toString            return  this- gt value           class Monday extends DaysOfWeekEnum      public function   construct            parent    construct  Monday             class Tuesday extends DaysOfWeekEnum      public function   construct            parent    construct  Tuesday              Then you can have your methods take an instance of DaysOfWeek and pass it an instance of Monday  Tuesday  etc    The only downside is having to  new-up  an instance every time you want to use your enum  but I find it worth it   function printWeekDay DaysOfWeek  day       echo  Today is  day       printWeekDay new Monday

User · Answer

I use a construction like the following for simple enums  Typically you can use them for switch statements     lt  php    define  OPTION 1    1      define  OPTION 2   OPTION 1   1     define  OPTION 3   OPTION 2   1         Some function       switch  Val       case OPTION 1   Perform 1    break      case OPTION 2   Perform 2    break                gt    It is not as conviniet as a native enum like in C   but it seems to work and requires less maintenance if you later would like to add an option in between

User · Answer

My Enum class definition below is Strongly typed  and very natural to use and define   Definition   class Fruit extends Enum       static public  APPLE   1      static public  ORANGE   2    Fruit  initialize      Can also be called in autoloader   Switch over Enum   myFruit   Fruit   APPLE   switch   myFruit        case Fruit   APPLE    echo  I like apples n    break      case Fruit   ORANGE   echo  I hate oranges n   break      gt  gt  I like apples   Pass Enum as parameter  Strongly typed       Function only accepts Fruit enums as input    function echoFruit Fruit  fruit        echo  fruit- gt getName         fruit- gt getValue     n          Call function with each Enum value that Fruit has    foreach  Fruit  getList   as  fruit        echoFruit  fruit        Call function with Apple enum echoFruit Fruit   APPLE     Will produce an error  This solution is strongly typed echoFruit 2     gt  gt  APPLE  1  gt  gt  ORANGE  2  gt  gt  APPLE  1  gt  gt  Argument 1 passed to echoFruit   must be an instance of Fruit  integer given   Echo Enum as string  echo  I have an  myFruit n     gt  gt  I have an APPLE   Get Enum by integer   myFruit   Fruit  getByValue 2    echo  Now I have an  myFruit n     gt  gt  Now I have an ORANGE   Get Enum by Name   myFruit   Fruit  getByName  APPLE     echo  But I definitely prefer an  myFruit n n     gt  gt  But I definitely prefer an APPLE   The Enum Class           author Torge Kummerow     class Enum                   Holds the values for each type of Enum             static private  list   array                    Initializes the enum values by replacing the number with an instance of itself        using reflection             static public function initialize              className   get called class             class   new ReflectionClass  className            staticProperties    class- gt getStaticProperties             self   list  className    array             foreach   staticProperties as  propertyName   gt   amp  value                if   propertyName     list                   continue                enum   new  className  propertyName   value                class- gt setStaticPropertyValue  propertyName   enum               self   list  className   propertyName     enum            unset  value                          Gets the enum for the given value                param integer  value         throws Exception                return Enum             static public function getByValue  value             className   get called class            foreach  self   list  className  as  propertyName  gt  amp  enum                    var  enum Enum                if   enum- gt value     value                  return  enum            unset  enum            throw new Exception  No such enum with value  value of type   get called class                           Gets the enum for the given name                param string  name         throws Exception                return Enum             static public function getByName  name             className   get called class            if  array key exists  name  static   list  className                return self   list  className   name            throw new Exception  No such enum   get called class         name                           Returns the list of all enum variants         return Array of Enum             static public function getList              className   get called class            return self   list  className               private  name      private  value       public function   construct  name   value             this- gt name    name           this- gt value    value             public function   toString             return  this- gt name             public function getValue             return  this- gt value             public function getName             return  this- gt name             Addition  You can ofcourse also add comments for IDEs  class Fruit extends Enum                   This comment is for autocomplete support in common IDEs         var Fruit A yummy apple             static public  APPLE   1                  This comment is for autocomplete support in common IDEs         var Fruit A sour orange             static public  ORANGE   2       This can also go to the autoloader if available  Fruit  initialize

User · Answer

A simpler and lighter version that doesn t use reflection   abstract class enum       private function   construct          static function has  const             name   get called class            return defined   name   const              static function value  const             name   get called class            return defined   name   const    constant   name   const     false            Usage   class requestFormat  extends enum   const HTML   1  const JSON   2  const XML    3  const FORM   4     echo requestFormat  value  JSON       2 echo requestFormat  has  JSON         true   This gives the advantage of constants and also allows for checking the validity of them but it lacks other fancy functionality provided by more complex solutions given is this question  the more obvious the inability of checking the reverse of a value  in the example above  you can t check if  2  is a valid value

User · Answer

class DayOfWeek       static  values   array          self  MONDAY          self  TUESDAY                             const MONDAY    0      const TUESDAY   1                 today   DayOfWeek  MONDAY      If you want to check if a value is valid assert  in array   today  DayOfWeek   values        Don t use reflection  It makes it extremely difficult to reason about your code and track down where something is being used  and tends to break static analysis tools  eg what s built into your IDE

User · Answer

abstract class Enumeration       public static function enum                   reflect   new ReflectionClass  get called class              return  reflect- gt getConstants              class Test extends Enumeration       const A    a       const B    b           foreach  Test  enum   as  key   gt   value        echo   key - gt   value lt br gt

User · Answer

I use interface instead of class   interface DaysOfWeek       const Sunday   0      const Monday   1         etc     var  today   DaysOfWeek  Sunday

User · Answer

What about class constants    lt  php  class YourClass       const SOME CONSTANT   1       public function echoConstant                 echo self  SOME CONSTANT           echo YourClass  SOME CONSTANT    c   new YourClass   c- gt echoConstant

User · Answer

I use interface instead of class   interface DaysOfWeek       const Sunday   0      const Monday   1         etc     var  today   DaysOfWeek  Sunday

User · Answer

If you need to use enums that are globally unique  i e  even when comparing elements between different Enums  and are easy to use  feel free to use the following code  I also added some methods that I find useful  You will find examples in the comments at the very top of the code    lt  php         Class Enum         author Christopher Fox  lt christopher fox gmx de gt         version 1 0       This class provides the function of an enumeration     The values of Enum elements are unique  even between different Enums     as you would expect them to be        Constructing a new Enum                                    In the following example we construct an enum called  UserState     with the elements  inactive    active    banned  and  deleted           lt code gt     Enum  Create  UserState    inactive    active    banned    deleted        lt  code gt        Using Enums                        The following example demonstrates how to compare two Enum elements        lt code gt     var dump UserState  inactive    UserState  banned      result  false    var dump UserState  active    UserState  active      result  true     lt  code gt        Special Enum methods                                 Get the number of elements in an Enum         lt code gt     echo UserState  CountEntries       result  4     lt  code gt        Get a list with all elements of the Enum         lt code gt      allUserStates   UserState  GetEntries        lt  code gt        Get a name of an element         lt code gt     echo UserState  GetName UserState  deleted      result  deleted     lt  code gt        Get an integer ID for an element  e g  to store as a value in a database table      This is simply the index of the element  beginning with 1      Note that this ID is only unique for this Enum but now between different Enums         lt code gt     echo UserState  GetDatabaseID UserState  active      result  2     lt  code gt      class Enum                    var Enum  instance The only instance of Enum  Singleton              private static  instance                   var array  enums    An array of all enums with Enum names as keys                 and arrays of element names as values             private  enums                  Constructs  the only  Enum instance             private function   construct                  this- gt enums   array                          Constructs a new enum                param string  name The class name for the enum         param mixed    A list of strings to use as names for enum entries             public static function Create  name                       Create  the only  Enum instance if this hasn t happened yet         if  self   instance   null                        self   instance   new Enum                          Fetch the arguments of the function          args   func get args               Exclude the  name  argument from the array of function arguments             so only the enum element names remain in the array         array shift  args           self   instance- gt add  name   args                         Creates an enumeration if this hasn t happened yet                 param string  name The class name for the enum         param array  fields The names of the enum elements             private function add  name   fields                if   array key exists  name   this- gt enums                          this- gt enums  name    array                    Generate the code of the class for this enumeration              classDeclaration        class      name       n                             private static   name         name       n                             this- gt getClassConstants  name   fields                             this- gt getFunctionGetEntries  name                             this- gt getFunctionCountEntries  name                             this- gt getFunctionGetDatabaseID                              this- gt getFunctionGetName                                                  Create the class for this enumeration             eval  classDeclaration                                   Returns the code of the class constants        for an enumeration  These are the representations        of the elements                  param string  name The class name for the enum         param array  fields The names of the enum elements                return string The code of the class constants             private function getClassConstants  name   fields                 constants                foreach   fields as  field                           Create a unique ID for the Enum element                This ID is unique because class and variables                names can t contain a semicolon  Therefore we                can use the semicolon as a separator here               uniqueID    name          field               constants       const      field            uniqueID       n                  Store the unique ID             array push  this- gt enums  name    uniqueID                      return  constants                        Returns the code of the function  GetEntries           for an enumeration                 param string  name The class name for the enum                return string The code of the function  GetEntries                private function getFunctionGetEntries  name                  entryList                           Put the unique element IDs in single quotes and            separate them with commas         foreach   this- gt enums  name  as  key   gt   entry                        if   key  gt  0   entryList                      entryList           entry                           return   public static function GetEntries      n                  return array      entryList       n                   n                         Returns the code of the function  CountEntries           for an enumeration                 param string  name The class name for the enum                return string The code of the function  CountEntries                private function getFunctionCountEntries  name                    This function will simply return a constant number  e g  return 5           return   public static function CountEntries      n                  return     count  this- gt enums  name        n                   n                         Returns the code of the function  GetDatabaseID           for an enumeration                 return string The code of the function  GetDatabaseID                private function getFunctionGetDatabaseID                    Check for the index of this element inside of the array            of elements and add  1         return   public static function GetDatabaseID   entry     n                   key   array search   entry  self  GetEntries     n                  return   key   1  n                   n                         Returns the code of the function  GetName           for an enumeration                return string The code of the function  GetName                private function getFunctionGetName                    Remove the class name from the unique ID             and return this value  which is the element name          return   public static function GetName   entry     n                 return substr   entry  strlen self    name    1   strlen   entry    n                   n                gt

User · Answer

I used classes with constants   class Enum       const NAME          aaaa       const SOME VALUE    bbbb      print Enum  NAME

User · Answer

I used classes with constants   class Enum       const NAME          aaaa       const SOME VALUE    bbbb      print Enum  NAME

User · Answer

Four years later I came across this again  My current approach is this as it allows for code completion in the IDE as well as type safety   Base class   abstract class TypedEnum       private static   instancedValues       private   value      private   name       private function   construct  value   name                 this- gt  value    value           this- gt  name    name             private static function  fromGetter  getter   value                 reflectionClass   new ReflectionClass get called class              methods    reflectionClass- gt getMethods ReflectionMethod  IS STATIC   ReflectionMethod  IS PUBLIC                className   get called class             foreach  methods as  method                        if   method- gt class      className                                 enumItem    method- gt invoke null                    if   enumItem instanceof  className  amp  amp   enumItem- gt  getter        value                                        return  enumItem                                                     throw new OutOfRangeException               protected static function  create  value                if  self    instancedValues     null                        self    instancedValues   array                        className   get called class             if   isset self    instancedValues  className                          self    instancedValues  className    array                       if   isset self    instancedValues  className   value                           debugTrace   debug backtrace                 lastCaller   array shift  debugTrace                while   lastCaller  class        className  amp  amp  count  debugTrace   gt  0                                 lastCaller   array shift  debugTrace                              self    instancedValues  className   value    new static  value   lastCaller  function                        return self    instancedValues  className   value              public static function fromValue  value                return self   fromGetter  getValue    value              public static function fromName  value                return self   fromGetter  getName    value              public function getValue                 return  this- gt  value             public function getName                 return  this- gt  name            Example Enum   final class DaysOfWeek extends TypedEnum       public static function Sunday     return self   create 0             public static function Monday     return self   create 1         public static function Tuesday     return self   create 2            public static function Wednesday     return self   create 3         public static function Thursday     return self   create 4           public static function Friday     return self   create 5         public static function Saturday     return self   create 6               Example usage   function saveEvent DaysOfWeek  weekDay   comment           store week day numeric value and comment       myDatabase- gt save  myeventtable           array  weekday id    gt   weekDay- gt getValue            array  comment    gt   comment          call the function  note  DaysOfWeek  Monday   returns an object of type DaysOfWeek saveEvent DaysOfWeek  Monday     some comment      Note that all instances of the same enum entry are the same    monday1   DaysOfWeek  Monday     monday2   DaysOfWeek  Monday     monday1      monday2     true   You can also use it inside of a switch statement   function getGermanWeekDayName DaysOfWeek  weekDay        switch   weekDay                case DaysOfWeek  Monday    return  Montag           case DaysOfWeek  Tuesday    return  Dienstag                      You can also create an enum entry by name or value    monday   DaysOfWeek  fromValue 2    tuesday   DaysOfWeek  fromName  Tuesday      Or you can just get the name  i e  the function name  from an existing enum entry    wednesday   DaysOfWeek  Wednesday   echo  wednesDay- gt getName       Wednesday

User · Answer

My attempt to create an enum with PHP   it s extremely limited since it doesn t support objects as the enum values but still somewhat useful     class ProtocolsEnum        const HTTP    1       const HTTPS    2       const FTP    3                   Retrieve an enum value         param string  name         return string             public static function getValueByName  name            return constant  self      name                          Retrieve an enum key name         param string  code         return string             public static function getNameByValue  code            foreach get class constants   as  key   gt   val                if  val     code                    return  key                                                Retrieve associate array of all constants  used for creating droplist options          return multitype              public static function toArray                   return array flip self  get class constants                private static function get class constants                  reflect   new ReflectionClass   CLASS             return  reflect- gt getConstants

User · Answer

This is my take on  dynamic  enum    so that i can call it with variables  ex  from a form   look at updated verison below this codeblock      value    concert    Enumvalue   EnumCategory  enum  value      EnumValue   1  class EnumCategory      const concert   1      const festival   2      const sport   3      const nightlife   4      const theatre   5      const musical   6      const cinema   7      const charity   8      const museum   9      const other   10       public function enum  string           return constant  EnumCategory     string             UPDATE  Better way of doing it     class EnumCategory        static  concert   1      static  festival   2      static  sport   3      static  nightlife   4      static  theatre   5      static  musical   6      static  cinema   7      static  charity   8      static  museum   9      static  other   10       Call with  EnumCategory     category

User · Answer

If you need to use enums that are globally unique  i e  even when comparing elements between different Enums  and are easy to use  feel free to use the following code  I also added some methods that I find useful  You will find examples in the comments at the very top of the code    lt  php         Class Enum         author Christopher Fox  lt christopher fox gmx de gt         version 1 0       This class provides the function of an enumeration     The values of Enum elements are unique  even between different Enums     as you would expect them to be        Constructing a new Enum                                    In the following example we construct an enum called  UserState     with the elements  inactive    active    banned  and  deleted           lt code gt     Enum  Create  UserState    inactive    active    banned    deleted        lt  code gt        Using Enums                        The following example demonstrates how to compare two Enum elements        lt code gt     var dump UserState  inactive    UserState  banned      result  false    var dump UserState  active    UserState  active      result  true     lt  code gt        Special Enum methods                                 Get the number of elements in an Enum         lt code gt     echo UserState  CountEntries       result  4     lt  code gt        Get a list with all elements of the Enum         lt code gt      allUserStates   UserState  GetEntries        lt  code gt        Get a name of an element         lt code gt     echo UserState  GetName UserState  deleted      result  deleted     lt  code gt        Get an integer ID for an element  e g  to store as a value in a database table      This is simply the index of the element  beginning with 1      Note that this ID is only unique for this Enum but now between different Enums         lt code gt     echo UserState  GetDatabaseID UserState  active      result  2     lt  code gt      class Enum                    var Enum  instance The only instance of Enum  Singleton              private static  instance                   var array  enums    An array of all enums with Enum names as keys                 and arrays of element names as values             private  enums                  Constructs  the only  Enum instance             private function   construct                  this- gt enums   array                          Constructs a new enum                param string  name The class name for the enum         param mixed    A list of strings to use as names for enum entries             public static function Create  name                       Create  the only  Enum instance if this hasn t happened yet         if  self   instance   null                        self   instance   new Enum                          Fetch the arguments of the function          args   func get args               Exclude the  name  argument from the array of function arguments             so only the enum element names remain in the array         array shift  args           self   instance- gt add  name   args                         Creates an enumeration if this hasn t happened yet                 param string  name The class name for the enum         param array  fields The names of the enum elements             private function add  name   fields                if   array key exists  name   this- gt enums                          this- gt enums  name    array                    Generate the code of the class for this enumeration              classDeclaration        class      name       n                             private static   name         name       n                             this- gt getClassConstants  name   fields                             this- gt getFunctionGetEntries  name                             this- gt getFunctionCountEntries  name                             this- gt getFunctionGetDatabaseID                              this- gt getFunctionGetName                                                  Create the class for this enumeration             eval  classDeclaration                                   Returns the code of the class constants        for an enumeration  These are the representations        of the elements                  param string  name The class name for the enum         param array  fields The names of the enum elements                return string The code of the class constants             private function getClassConstants  name   fields                 constants                foreach   fields as  field                           Create a unique ID for the Enum element                This ID is unique because class and variables                names can t contain a semicolon  Therefore we                can use the semicolon as a separator here               uniqueID    name          field               constants       const      field            uniqueID       n                  Store the unique ID             array push  this- gt enums  name    uniqueID                      return  constants                        Returns the code of the function  GetEntries           for an enumeration                 param string  name The class name for the enum                return string The code of the function  GetEntries                private function getFunctionGetEntries  name                  entryList                           Put the unique element IDs in single quotes and            separate them with commas         foreach   this- gt enums  name  as  key   gt   entry                        if   key  gt  0   entryList                      entryList           entry                           return   public static function GetEntries      n                  return array      entryList       n                   n                         Returns the code of the function  CountEntries           for an enumeration                 param string  name The class name for the enum                return string The code of the function  CountEntries                private function getFunctionCountEntries  name                    This function will simply return a constant number  e g  return 5           return   public static function CountEntries      n                  return     count  this- gt enums  name        n                   n                         Returns the code of the function  GetDatabaseID           for an enumeration                 return string The code of the function  GetDatabaseID                private function getFunctionGetDatabaseID                    Check for the index of this element inside of the array            of elements and add  1         return   public static function GetDatabaseID   entry     n                   key   array search   entry  self  GetEntries     n                  return   key   1  n                   n                         Returns the code of the function  GetName           for an enumeration                return string The code of the function  GetName                private function getFunctionGetName                    Remove the class name from the unique ID             and return this value  which is the element name          return   public static function GetName   entry     n                 return substr   entry  strlen self    name    1   strlen   entry    n                   n                gt

User · Answer

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- gt getConstants               return self   constCacheArray  calledClass

User · Answer

If you want type safety and a bunch of constants that match that type  one way to go is to have an abstract class for your enum and then extend that class with a locked constructor  like so   abstract class DaysOfWeekEnum      public function   construct string  value            this- gt value    value             public function   toString            return  this- gt value           class Monday extends DaysOfWeekEnum      public function   construct            parent    construct  Monday             class Tuesday extends DaysOfWeekEnum      public function   construct            parent    construct  Tuesday              Then you can have your methods take an instance of DaysOfWeek and pass it an instance of Monday  Tuesday  etc    The only downside is having to  new-up  an instance every time you want to use your enum  but I find it worth it   function printWeekDay DaysOfWeek  day       echo  Today is  day       printWeekDay new Monday

User · Answer

It might be as simple as  enum DaysOfWeek       Sunday      Monday                 in the future   PHP RFC  Enumerated Types

User · Answer

What about class constants    lt  php  class YourClass       const SOME CONSTANT   1       public function echoConstant                 echo self  SOME CONSTANT           echo YourClass  SOME CONSTANT    c   new YourClass   c- gt echoConstant

User · Answer

What about class constants    lt  php  class YourClass       const SOME CONSTANT   1       public function echoConstant                 echo self  SOME CONSTANT           echo YourClass  SOME CONSTANT    c   new YourClass   c- gt echoConstant

User · Answer

I realize this is a very-very-very old thread but I had a thought about this and wanted to know what people thought   Notes  I was playing around with this and realized that if I just modified the   call   function that you can get even closer to actual enums   The   call   function handles all unknown function calls   So let s say you want to make three enums RED LIGHT  YELLOW LIGHT  and GREEN LIGHT   You can do so now by just doing the following    c- gt RED LIGHT     c- gt YELLOW LIGHT     c- gt GREEN LIGHT      Once defined all you have to do is to call them again to get the values   echo  c- gt RED LIGHT    echo  c- gt YELLOW LIGHT    echo  c- gt GREEN LIGHT      and you should get 0  1  and 2   Have fun   This is also now up on GitHub   Update   I ve made it so both the   get   and   set   functions are now used   These allow you to not have to call a function unless you want to   Instead  now you can just say    c- gt RED LIGHT   c- gt YELLOW LIGHT   c- gt GREEN LIGHT    For both the creation and getting of the values   Because the variables haven t been defined initially  the   get   function is called  because there isn t a value specified  which sees that the entry in the array hasn t been made   So it makes the entry  assigns it the last value given plus one  1   increments the last value variable  and returns TRUE   If you set the value    c- gt RED LIGHT   85    Then the   set   function is called and the last value is then set to the new value plus one   1    So now we have a fairly good way to do enums and they can be created on the fly    lt  php                                                                                      Class ENUMS           Original code by Mark Manning          Copyrighted  c  2015 by Mark Manning          All rights reserved            This set of code is hereby placed into the free software universe         via the GNU greater license thus placing it under the Copyleft         rules and regulations with the following modifications            1  You may use this work in any other work   Commercial or otherwise          2  You may make as much money as you can with it          3  You owe me nothing except to give me a small blurb somewhere in             your program or maybe have pity on me and donate a dollar to             sim sales paypal com    -        Blurb            PHP Class Enums by Mark Manning  markem-AT-sim1-DOT-us           Used with permission        Notes            VIM formatting   Set tabs to four 4  spaces                                                                                     class enums       private  enums      private  clear flag      private  last value                                                                                          construct    Construction function   Optionally pass in your enums                                                                                   function   construct          this- gt enums   array         this- gt clear flag   false       this- gt last value   0       if  func num args    gt  0            return  this- gt put  func get args                     return true                                                                                         put    Insert one or more enums                                                                                   function put          args   func get args          Did they send us an array of enums      Ex   c- gt put  array   a   gt 0   b   gt 1             OR   c- gt put  array   a    b    c                 if  is array  args 0            Add them all in           foreach   args 0  as  k  gt  v          Don t let them change it once it is set      Remove the IF statement if you want to be able to modify the enums                if   isset  this- gt enums  k            If they sent an array of enums like this   a   b   c      then we have to     change that to be  A   gt    Where     is the current count of the enums                    if  is numeric  k                          this- gt enums  v     this- gt last value                                Else - they sent  a   gt  A    b   gt  B    c   gt  C                           else                            this- gt last value    v   1                           this- gt enums  k     v                                                                            Nope   Did they just sent us one enum            else         Is this just a default declaration      Ex   c- gt put   a                   if  count  args   lt  2          Again - remove the IF statement if you want to be able to change the enums                    if   isset  this- gt enums  args 0                            this- gt enums  args 0      this- gt last value                                No - they sent us a regular enum     Ex   c- gt put   a    This is the first enum                           else         Again - remove the IF statement if you want to be able to change the enums                            if   isset  this- gt enums  args 0                                    this- gt last value    args 1    1                               this- gt enums  args 0      args 1                                                                                                return true                                                                                         get    Get one or more enums                                                                                   function get          num   func num args         args   func get args          Is this an array of enums request   ie   c- gt get array  a   b   c               if  is array  args 0               ary   array            foreach   args 0  as  k  gt  v                 ary  v     this- gt enums  v                          return  ary                  Is it just ONE enum they want   ie   c- gt get  a               else if    num  gt  0   amp  amp    num  lt  2                 return  this- gt enums  args 0                        Is it a list of enums they want   ie   c- gt get   a    b    c                  else if   num  gt  1                 ary   array                foreach   args as  k  gt  v                     ary  v     this- gt enums  v                                  return  ary                      They either sent something funky or nothing at all        return false                                                                                         clear    Clear out the enum array          Optional   Set the flag in the   construct function          After all  ENUMS are supposed to be constant                                                                                   function clear         if   clear flag            unset   this- gt enums             this- gt enums   array                   return true                                                                                           call     In case someone tries to blow up the class                                                                                   function   call   name   arguments         if  isset  this- gt enums  name      return  this- gt enums  name             else if   isset  this- gt enums  name    amp  amp   count  arguments   gt  0                  this- gt last value    arguments 0    1               this- gt enums  name     arguments 0               return true                        else if   isset  this- gt enums  name    amp  amp   count  arguments   lt  1                  this- gt enums  name     this- gt last value                return true                     return false                                                                                           get    Gets the value                                                                                   function   get  name        if  isset  this- gt enums  name      return  this- gt enums  name             else if   isset  this- gt enums  name                   this- gt enums  name     this- gt last value                return true                     return false                                                                                           set     Sets the value                                                                                   function   set   name   value null         if  isset  this- gt enums  name      return false            else if   isset  this- gt enums  name    amp  amp   is null  value                  this- gt last value    value   1               this- gt enums  name     value              return true                        else if   isset  this- gt enums  name    amp  amp  is null  value                  this- gt enums  name     this- gt last value                return true                     return false                                                                                           destruct     Deconstruct the class   Remove the list of enums                                                                                   function   destruct         unset   this- gt enums         this- gt enums   null       return true             Test code        c   new enums         c- gt RED LIGHT 85        c- gt YELLOW LIGHT   23       c- gt GREEN LIGHT        echo  c- gt RED LIGHT     n       echo  c- gt YELLOW LIGHT     n       echo  c- gt GREEN LIGHT     n      gt

User · Answer

My Enumeration Class class Enum       protected  m actions   array         public function   construct  actions                 this- gt init  actions              public function init  actions                 this- gt m actions   array            for  i   0   i  lt  count  actions      i                         this- gt m actions  actions  i       i   1                define  actions  i     i   1                         public function toString  index                 keys   array keys  this- gt m actions           for  i   0   i  lt  count  keys      i                        if  this- gt m actions  keys  i       index                                return  keys  i                                    return  undefined              public function fromString  str                return  this- gt m actions  str               Enumeration creation  actions   new Enum array  CREATE    READ    UPDATE    DELETE         Examples print  action objects- gt toString DELETE    print  action objects- gt fromString  DELETE      if  action objects- gt fromString   POST  myAction       CREATE        print  CREATE

User · Answer

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- gt 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

User · Answer

Some good solutions on here  Here s my version   It s strongly typed It works with IDE auto-completion Enums are defined by a code and a description  where the code can be an integer  a binary value  a short string  or basically anything else you want   The pattern could easily be extended to support orther properties  It asupports value      and reference       comparisons and works in switch statements   I think the main disadvantage is that enum members do have to be separately declared and instantiated  due to the descriptions and PHP s inability to construct objects at static member declaration time   I guess a way round this might be to use reflection with parsed doc comments instead  The abstract enum looks like this   lt  php  abstract class AbstractEnum            var array cache of all enum instances by class name and integer value        private static  allEnumMembers   array              var mixed        private  code            var string        private  description                  Return an enum instance of the concrete type on which this static method is called  assuming an instance        exists for the passed in value   Otherwise an exception is thrown                 param  code         return AbstractEnum         throws Exception             public static function getByCode  code                 concreteMembers    amp self  getConcreteMembers             if  array key exists  code   concreteMembers                 return  concreteMembers  code                      throw new Exception  quot Value   code  does not exist for enum   quot  get called class    quot   quot               public static function getAllMembers                 return self  getConcreteMembers                          Create  cache and return an instance of the concrete enum type for the supplied primitive value                 param mixed  code code to uniquely identify this enum         param string  description         throws Exception         return AbstractEnum             protected static function enum  code   description                 concreteMembers    amp self  getConcreteMembers             if  array key exists  code   concreteMembers                 throw new Exception  quot Value   code  has already been added to enum   quot  get called class    quot   quot                        concreteMembers  code     concreteEnumInstance   new static  code   description            return  concreteEnumInstance                         return AbstractEnum               private static function  amp getConcreteMembers              thisClassName   get called class             if   array key exists  thisClassName  self   allEnumMembers                  concreteMembers   array                self   allEnumMembers  thisClassName     concreteMembers                     return self   allEnumMembers  thisClassName              private function   construct  code   description                 this- gt code    code           this- gt description    description             public function getCode                 return  this- gt code             public function getDescription                 return  this- gt description           Here s an example concrete enum   lt  php  require  AbstractEnum php     class EMyEnum extends AbstractEnum            var EMyEnum        public static  MY FIRST VALUE           var EMyEnum        public static  MY SECOND VALUE           var EMyEnum        public static  MY THIRD VALUE       public static function  init                 self   MY FIRST VALUE   self  enum 1   My first value            self   MY SECOND VALUE   self  enum 2   My second value            self   MY THIRD VALUE   self  enum 3   My third value             EMyEnum   init     Which can be used like this   lt  php  require  EMyEnum php     echo EMyEnum   MY FIRST VALUE- gt getCode         EMyEnum   MY FIRST VALUE- gt getDescription   PHP EOL PHP EOL   var dump EMyEnum  getAllMembers      echo PHP EOL EMyEnum  getByCode 2 - gt getDescription   PHP EOL   And produces this output   1   My first value array 3         1   gt      object EMyEnum  1  2            quot code quot   quot AbstractEnum quot  private   gt        int 1          quot description quot   quot AbstractEnum quot  private   gt        string 14   quot My first value quot             2   gt      object EMyEnum  2  2            quot code quot   quot AbstractEnum quot  private   gt        int 2          quot description quot   quot AbstractEnum quot  private   gt        string 15   quot My second value quot             3   gt      object EMyEnum  3  2            quot code quot   quot AbstractEnum quot  private   gt        int 3          quot description quot   quot AbstractEnum quot  private   gt        string 14   quot My third value quot             My second value

User · Answer

Well  for a simple java like enum in php  I use   class SomeTypeName       private static  enum   array 1   gt   Read   2   gt   Write         public function toOrdinal  name            return array search  name  self   enum              public function toString  ordinal            return self   enum  ordinal             And to call it   SomeTypeName  toOrdinal  Read    SomeTypeName  toString 1     But I m a PHP beginner  struggling with the syntax so this might not be the best way  I experimented some with Class Constants  using Reflection to get the constant name from it s value  might be neater

User · Answer

Pointed out solution works well  Clean and smooth   However  if you want strongly typed enumerations  you can use this   class TestEnum extends Enum       public static  TEST1      public static  TEST2    TestEnum  init       Automatically initializes enum values   With an Enum class looking like   class Enum       public static function parse  enum                 class   get called class             vars   get class vars  class           if  array key exists  enum   vars                 return  vars  enum                     return null             public static function init                  className   get called class             consts   get class vars  className           foreach   consts as  constant   gt   value                if  is null  className    constant                      constantValue    constant                   constantValueName    className           constant     VALUE                   if  defined  constantValueName                          constantValue   constant  constantValueName                                      className    constant   new  className  constantValue                                      public function   construct  value                 this- gt value    value            This way  enum values are strongly typed and   TestEnum   TEST1     TestEnum  parse  TEST1      true statement

User · Answer

I have recently developed a simple library for PHP Enums  https   github com dnl-blkv simple-php-enum  At the moment of writing this answer  it is still in pre-release stage  but already fully-functional  well-documented and published on Packagist   This might be a handy option if you are looking for easy-to-implement enums similar to those of C C

User · Answer

I use a construction like the following for simple enums  Typically you can use them for switch statements     lt  php    define  OPTION 1    1      define  OPTION 2   OPTION 1   1     define  OPTION 3   OPTION 2   1         Some function       switch  Val       case OPTION 1   Perform 1    break      case OPTION 2   Perform 2    break                gt    It is not as conviniet as a native enum like in C   but it seems to work and requires less maintenance if you later would like to add an option in between

User · Answer

The accepted answer is the way to go and is actually what I am doing for simplicity  Most advantages of enumeration are offered  readable  fast  etc    One concept is missing  however  type safety  In most languages  enumerations are also used to restrict allowed values  Below is an example of how type safety can also be obtained by using private constructors  static instantiation methods and type checking   class DaysOfWeek   const Sunday   0   const Monday   1      etc    private  intVal   private function   construct  intVal       this- gt intVal    intVal         static instantiation methods  public static function MONDAY       return new self self  Monday         etc       function using type checking function printDayOfWeek DaysOfWeek  d     compiler can now use type checking      to something with  d         calling the function is safe  printDayOfWeek DaysOfWeek  MONDAY       We could even go further  using constants in the DaysOfWeek class might lead to misusage  e g  one might mistakenly use it this way   printDayOfWeek DaysOfWeek  Monday     triggers a compiler error    which is wrong  calls integer constant   We can prevent this using private static variables instead of constants   class DaysOfWeeks     private static  monday   1      etc     private  intVal      private constructor   private function   construct  intVal        this- gt intVal    intVal           public instantiation methods   public static function MONDAY        return new self self   monday           etc        convert an instance to its integer value   public function intVal        return  this- gt intVal           Of course  it is not possible to access integer constants  this was actually the purpose   The intVal method allows to convert a DaysOfWeek object to its integer representation   Note that we could even go further by implementing a caching mechanism in instantiation methods to save memory in the case enumerations are extensively used     Hope this will help

User · Answer

I like enums from java too and for this reason I write my enums in this way  I think this is the most similiar behawior like in Java enums  of course  if some want to use more methods from java should write it here  or in abstract class but core idea is embedded in code below   class FruitsEnum        static  APPLE   null      static  ORANGE   null       private  value   null       public static  map       public function   construct  value             this- value    value             public static function init              self   APPLE    new FruitsEnum  Apple            self   ORANGE   new FruitsEnum  Orange              static map to get object by name - example Enum  get  INIT   - returns Enum   INIT object          self   map   array                Apple     self   APPLE               Orange     self   ORANGE                       public static function get  element            if  element    null              return null          return self   map  element              public function getValue             return  this- value             public function equals FruitsEnum  element            return  element- getValue       this- getValue               public function   toString              return  this- value          FruitsEnum  init     var dump FruitsEnum   APPLE- equals FruitsEnum   APPLE      true var dump FruitsEnum   APPLE- equals FruitsEnum   ORANGE      false var dump FruitsEnum   APPLE instanceof FruitsEnum     true var dump FruitsEnum  get  Apple  - equals FruitsEnum   APPLE      true - enum from string var dump FruitsEnum  get  Apple  - equals FruitsEnum  get  Orange        false

User · Answer

based on  this gist  a base class for all enum   abstract class Enum       protected  val       protected function   construct  arg             this- gt val    arg             public function   toString             return  this- gt val             public function   set  arg1   arg2            throw new Exception  enum does not have property               public function   get  arg1            throw new Exception  enum does not have property                  not really needed     public function   call  arg1   arg2            throw new Exception  enum does not have method                  not really needed     static public function   callStatic  arg1   arg2            throw new Exception  enum does not have static method              your enum   final class MyEnum extends Enum       static public function val1             return new self  val1               static public function val2             return new self  val2               static public function val3             return new self  val3              test it    a   MyEnum  val1    echo  1 the enum value is   a  n    function consumeMyEnum MyEnum  arg        return  2 the return value is   arg  n      echo consumeMyEnum  a    version   explode      PHP VERSION   if   version 0   gt   7        try           echo consumeMyEnum  val1          catch  TypeError  e            echo  3 passing argument error happens  PHP 7 0 and above  n            echo   a    MyEnum  val1       4 same n     4 different n   echo   a    MyEnum  val2       5 same n     5 different n     b   MyEnum  val1    echo   a     b      6 same n     6 different n   echo   a      b     7 same n     7 different n     c   MyEnum  val2    echo   a     c      8 same n     8 different n   echo   a      c     9 same n     9 different n    switch   c        case MyEnum  val1    echo  10 case of 1st n   break      case MyEnum  val2    echo  11 case of 2nd n   break      case MyEnum  val3    echo  12 case of 3rd n   break     try        a- gt prop   10    catch  Exception  e        echo  13 set property error happens n      try       echo  a- gt prop    catch  Exception  e        echo  14 get property error happens n      try       echo  a- gt meth      catch  Exception  e        echo  15 method call error happens n      try       echo MyEnum  meth      catch  Exception  e        echo  16 static method call error happens n      class Ordinary    echo  a instanceof MyEnum      17 MyEnum instance n       17 not MyEnum instance n   echo  a instanceof Enum        18 Enum instance n         18 not Enum instance n   echo  a instanceof Ordinary    19 Ordinary instance n     19 not Ordinary instance n     try it online  sanbox

[php] Enumerations on PHP

Examples related to php

Examples related to enumeration