Skip to content
Enumeration implementation for PHP
Branch: master
Clone or download
Type Name Latest commit message Commit time
Failed to load latest commit information.
src InvalidEnumException for Enum::is() update May 26, 2019
tests add tests May 28, 2019
.gitignore Initial commit Mar 6, 2018
.travis.yml Add travis config Mar 6, 2018 Update changelog Jun 10, 2019
LICENSE Initial commit Mar 6, 2018 Update README to document API changes Sep 21, 2018
composer.json Fix package identifier Mar 6, 2018
composer.lock Fix package identifier Mar 6, 2018
phpunit.xml Initial commit Mar 6, 2018

Enum PHP Library

License: MIT Build Status Code Coverage Packagist


This library provides an Enum / Enumeration implementation for PHP.

Why use this library

  • Very simple to implement and use.
  • Complex can optionally be mapped by providing a map() method.
  • Allows type-hinting when passing enumerated values between methods and classes.


First create a new class that extends \Rexlabs\Enum\Enum and do the following;

  1. Declare your constants
  2. Optional: provide a map() method:



class City extends \Rexlabs\Enum\Enum
    const BRISBANE = 'Brisbane';
    const MELBOURNE = 'Melbourne';
    const SYDNEY = 'Sydney';
    // OPTIONAL - Provide a map() method if you would like to
    // map additional data, which will be available from the ->value() method
    public static function map(): array 
        return [
            static::BRISBANE => ["state"=>"QLD", "population"=>""],
            static::MELBOURNE => ["state"=>"VIC", "population"=>"5m"],
            static::SYDNEY => ["state"=>"NSW", "population"=>"5m"],

// Static access
echo City::BRISBANE;                 // "Brisbane"
echo City::MELBOURNE;                // "Melbourne"
City::names();                       // (array)["BRISBANE", "BRISBANE", "SYDNEY"]
City::keys();                        // (array)["Brisbane", "Melbourne", "Sydney"]
City::keyForName('BRISBANE');        // "Brisbane"
City::nameForKey('Melbourne');       // "MELBOURNE"
City::isValidKey('Sydney');          // (boolean)true
City::isValidKey('Paris');           // (boolean)false
// Getting an instance - all return a City instance.
$city = City::BRISBANE();                   
$city = City::instanceFromName('BRISBANE'); 
$city = City::instanceFromKey('Brisbane');

// Working with an instance
$city->name();                       // "BRISBANE"
$city->key();                        // "Brisbane"
$city->value()['population'];        // null - no value mapped
$city->is(City::BRISBANE);           // (boolean)true
$city->is(City::BRISBANE());         // (boolean)true
$city->is(City::SYDNEY());           // (boolean)false

// Or ...
City::SYDNEY()->key();               // "Sydney"
City::SYDNEY()->value();             // (array)["state"=>"NSW", "population"=>"5m"] 


  • PHP 7.0 or above.


To install in your project:

composer require rexlabs/enum


Now you can type-hint your Enum object as a dependency:

function announceCity(City $city) {
    echo "{$city->key()} is located in {$city->value()["state"]}, population: {$city->value()["population"]}\n";

// Get a new instance
announceCity(City::SYDNEY());      // "Sydney is located in NSW, population: 5m"

Instance Methods

Each instance of Enum provides the following methods:


Returns the constant name.



Returns the value/key assigned to the constant in the const MY_CONST = 'key' declaration.



Returns the value (if-any) that is mapped (in the array returned by map()). If no value is mapped, then this method returns null.


is(Enum|string $compare)

Returns true if this instance is the same as the given constant key or enumeration instance.

$enum->is(City::SYDNEY);       // Compare to constant key
$enum->is(City::SYDNEY());     // Compare to instance


The __toString() method is defined to return the constant name.

(string)City::SYDNEY();      // "SYDNEY"

Static Methods


Returns an array which maps the constant keys to a value. This method can be optionally implemented in a sub-class. The default implementation returns an array of keys mapped to null.


Returns an array of constant keys.


Returns an array of values defined in map(). If map() is not implemented then an array of null values will be returned.


Returns an array of all the constant names declared with the class.


Returns an associative array of CONSTANT_NAME => key, for all of the constant names declared within the class.

keyForName(string $name)

Returns the key for the given constant name.

nameForKey(string $key)

Returns the constant name for the given key (the inverse of keyForName).

valueForKey(string $key)

Returns the value (or null if not mapped) for the given key (as declared in the map() method).

keyForValue(mixed $value)

Returns the key for the given value (as declared in the map() method).

Note: If duplicate values are contained within the map() method then only the first key will be returned.


Create instance of this Enum from the given constant name.


Create instance of this Enum from the given key.

isValidKey(string $key)

Returns true if the given key exists.

isValidName(string $name)

Returns true if the given constant name (case-sensitive) has been declared in the class.

requireValidKey(string $key)

Throws a \Rexlabs\Enum\Exceptions\InvalidKeyException if the given key does NOT exist.


To run tests:

composer tests

To run coverage report:

composer coverage

Coverage report is output to ./tests/report/index.html


Contributions are welcome, please submit a pull-request or create an issue. Your submitted code should be formatted using PSR-1/PSR-2 standards.


  • Author: Jodie Dunlop
  • License: MIT
  • Copyright (c) 2018 Rex Software Pty Ltd
You can’t perform that action at this time.