PHP的Enum（枚举）的实现

SplEnum 
extends
 
SplType {
/* Constants */
const
 
NULL __default = null ;
/* 方法 */
public
 
array
 
getConstList ([ bool 
$include_default
 
= false ] )

SplType::__construct ([ mixed 
$initial_value
 
[, bool 
$strict
 
]] )
}

<?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
->getMessage() . PHP_EOL;
}
?>

<?php
/**
* Abstract class that enables creation of PHP enums. All you
* have to do is extend this class and define some constants.
* Enum is an object with value from on of those constants
* (or from on of superclass if any). There is also
* __default constat that enables you creation of object
* without passing enum value.
*
* @author Marijan Šuflaj <msufflaj32@gmail.com&gt
* @link http://php4every1.com
*/
abstract
 
class
 
Enum {
/**
* Constant with default value for creating enum object
*/
const
 
__default = null;
private
 
$value
;
private
 
$strict
;
private
 
static
 
$constants
 
= 
array
();
/**
* Returns list of all defined constants in enum class.
* Constants value are enum values.
*
* @param bool $includeDefault If true, default value is included into return
* @return array Array with constant values
*/
public
 
function
 
getConstList(
$includeDefault
 
= false) {
$class
 
= get_class(
$this
);
if
 
(!
array_key_exists
(
$class
, self::
$constants
)) {
self::populateConstants();
}
return
 
$includeDefault
 
? 
array_merge
(self::
$constants
[__CLASS_], 
array
(
"__default"
 
=> self::__default
)) : self::
$constants
[__CLASS_];
}
/**
* Creates new enum object. If child class overrides __construct(),
* it is required to call parent::__construct() in order for this
* class to work as expected.
*
* @param mixed $initialValue Any value that is exists in defined constants
* @param bool $strict If set to true, type and value must be equal
* @throws UnexpectedValueException If value is not valid enum value
*/
public
 
function
 
__construct(
$initialValue
 
= null, 
$strict
 
= true) {
$class
 
= get_class(
$this
);
if
 
(!
array_key_exists
(
$class
, self::
$constants
)) {
self::populateConstants();
}
if
 
(
$initialValue
 
=== null) {
$initialValue
 
= self::
$constants
[
$class
][
"__default"
];
}
$temp
 
= self::
$constants
[
$class
];
if
 
(!in_array(
$initialValue
, 
$temp
, 
$strict
)) {
throw
 
new
 
UnexpectedValueException(
"Value is not in enum "
 
. 
$class
);
}
$this
->value = 
$initialValue
;
$this
->strict = 
$strict
;
}
private
 
function
 
populateConstants() {
$class
 
= get_class(
$this
);
$r
 
= 
new
 
ReflectionClass(
$class
);
$constants
 
= 
$r
->getConstants();
self::
$constants
 
= 
array
(
$class
 
=> 
$constants
);
}
/**
* Returns string representation of an enum. Defaults to
* value casted to string.
*
* @return string String representation of this enum's value
*/
public
 
function
 
__toString() {
return
 
(string) 
$this
->value;
}
/**
* Checks if two enums are equal. Only value is checked, not class type also.
* If enum was created with $strict = true, then strict comparison applies
* here also.
*
* @return bool True if enums are equal
*/
public
 
function
 
equals(
$object
) {
if
 
(!(
$object
 
instanceof
 
Enum)) {
return
 
false;
}
return
 
$this
->strict ? (
$this
->value === 
$object
->value)
: (
$this
->value == 
$object
->value);
}
} 

class
 
MyEnum 
extends
 
Enum {
const
 
HI = 
"Hi"
;
const
 
BY = 
"By"
;
const
 
NUMBER = 1;
const
 
__default = self::BY;
}
var_dump(
new
 
MyEnum(MyEnum::HI));
var_dump(
new
 
MyEnum(MyEnum::BY));
//Use __default
var_dump(
new
 
MyEnum());
try
 
{
new
 
MyEnum(
"I don't exist"
);
} 
catch
 
(UnexpectedValueException 
$e
) {
var_dump(
$e
->getMessage());
}

object(MyEnum)#1 (2) {
["value":"Enum":private]=>
string(2) "Hi"
["strict":"Enum":private]=>
bool(true)
}
object(MyEnum)#1 (2) {
["value":"Enum":private]=>
string(2) "By"
["strict":"Enum":private]=>
bool(true)
}
object(MyEnum)#1 (2) {
["value":"Enum":private]=>
string(2) "By"
["strict":"Enum":private]=>
bool(true)
}
string(27) "Value is not in enum MyEnum"