4 Answers
  • 4

A PHP Error was encountered

Severity: Notice

Message: Undefined index: userid

Filename: views/question.php

Line Number: 190


File: /var/www/stackquestions.com/public_html/application/views/question.php
Line: 190
Function: _error_handler

File: /var/www/stackquestions.com/public_html/application/controllers/Questions.php
Line: 416
Function: view

File: /var/www/stackquestions.com/public_html/index.php
Line: 315
Function: require_once

name Punditsdkoslkdosdkoskdo

PHP and Enumerations

I know that PHP doesn't 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 (never?) know how to autofill their keys.

Are there any solutions/workarounds you commonly use? Does anyone recall whether the PHP guys have had any thoughts or decisions around enums?

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))->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;


Using Enum as a base class from which all other enumerations extend allows for helper methods, such as toArrayisValid, and so on. To me, typed enumerations (and managing their instances) just end up too messy.


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' => 1,
        'BAR' => 2,
        'QUX' => 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->_value = static::$_values[$name];

    public function __equals($object)
        if ($object instanceof static)
            return $object->_value === $this->_value;
        return $object === $this->_value;


$foo = TestEnum::$FOO; // object(TestEnum)#1 (1) {
                       //   ["_value":"TestEnum":private]=>
                       //   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
  • 0
Reply Report

I use interface instead of class:

interface DaysOfWeek
    const Sunday = 0;
    const Monday = 1;
    // etc.

var $today = DaysOfWeek::Sunday;
  • 1
Reply Report

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

abstract class DaysOfWeek
    const Sunday = 0;
    const Monday = 1;
    // etc.

$today = DaysOfWeek::Sunday;

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

abstract class BasicEnum {
    private static $constCacheArray = NULL;

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

    public static function isValidName($name, $strict = false) {
        $constants = self::getConstants();

        if ($strict) {
            return array_key_exists($name, $constants);

        $keys = array_map('strtolower', array_keys($constants));
        return in_array(strtolower($name), $keys);

    public static function isValidValue($value, $strict = true) {
        $values = array_values(self::getConstants());
        return in_array($value, $values, $strict);

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

abstract class DaysOfWeek extends BasicEnum {
    const Sunday = 0;
    const Monday = 1;
    const Tuesday = 2;
    const Wednesday = 3;
    const Thursday = 4;
    const Friday = 5;
    const Saturday = 6;

DaysOfWeek::isValidName('Humpday');                  // false
DaysOfWeek::isValidName('Monday');                   // true
DaysOfWeek::isValidName('monday');                   // true
DaysOfWeek::isValidName('monday', $strict = true);   // false
DaysOfWeek::isValidName(0);                          // false

DaysOfWeek::isValidValue(0);                         // true
DaysOfWeek::isValidValue(5);                         // true
DaysOfWeek::isValidValue(7);                         // false
DaysOfWeek::isValidValue('Friday');                  // false

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

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

  • 1
Reply Report