本文的实现主要是基于 myclabs/php-enum 扩展包。

今天来分享下如何管理 PHP 的枚举类型。

一种常见的方式是，使用常量来代表枚举类型

const YES = '是';

const NO = '否';

可以在这个基础上更进一步，将其封装成类，以便于管理。

1. class BoolEnum { 
2.  
3.     const YES = '是'; 
4.  
5.     const NO = '否'; 
6.  
7. } 

现在，我们希望能通过方法来动态调用对应的枚举类型

BoolEnum::YES(); // 是

BoolEnum::NO(); // 否

也可以批量获取枚举类型

BoolEnum::toArray(); // ['Yes' => '是', 'No' => '否']

下面来实现上面列举的功能。

定义基本的枚举基类，让所有的枚举类都继承该抽象基类。

1. abstract class Enum 
2.  
3. {    
4.  
5.     // 获取所有枚举类型 
6.  
7.     public static function toArray(){ 
8.  
9.         // 通过反射获取常量 
10.  
11.         $reflection = new \ReflectionClass(static::class); 
12.  
13.         $contants = $reflection->getConstants(); 
14.  
15.         // 返回对应的常量 
16.  
17.         return $contants; 
18.  
19.     } 
20.  
21.     //  动态调用属性 
22.  
23.     public static function __callStatic($name, $arguments) 
24.  
25.     { 
26.  
27.         $arr = static::toArray(); 
28.  
29.         if(isset($arr[$name])){ 
30.  
31.             return $arr[$name]; 
32.  
33.         } 
34.  
35.         throw new \BadMethodCallException("找不到对应的枚举值 {$name}"); 
36.  
37.     } 
38.  
39. } 
40.  
41. class BoolEnum extends Enum 
42.  
43. { 
44.  
45.     const YES = '是'; 
46.  
47.     const NO = '否'; 
48.  
49. } 

利用反射，可以获取到所有的枚举类型。同时，利用魔术方法则可以实现对属性的动态调用，这里要注意的是，反射会消耗较多的资源，因此，对 toArray 方法进行重构，增加一个缓存变量来缓存获取到的枚举类型，避免重复使用反射。

1. abstract class Enum 
2.  
3. {    
4.  
5.     protected static $cache = []; 
6.  
7.     public static function toArray(){ 
8.  
9.         $class = static::class; 
10.  
11.         // 第一次获取，就通过反射来获取 
12.  
13.         if(! isset(static::$cache[$class])){ 
14.  
15.             $reflection = new \ReflectionClass(static::class); 
16.  
17.             static::$cache[$class] = $reflection->getConstants(); 
18.  
19.         } 
20.  
21.         return static::$cache[$class]; 
22.  
23.     } 
24.  
25. } 

现在考虑更多的使用场景，比如用实例来代表特定枚举类型

$yes = new BoolEnum("是");

echo $yes; // "是"

实现如下：

1. abstract Enum  
2.  
3. { 
4.  
5.     protected $value; 
6.  
7.     public function __construct($value) 
8.  
9.     {    
10.  
11.         if ($value instanceof static) { 
12.  
13.             $value = $value->getValue(); 
14.  
15.         } 
16.  
17.         if(! $this->isValid($value)){ 
18.  
19.             throw new \UnexpectedValueException("$value 不属于该枚举值" . static::class); 
20.  
21.         } 
22.  
23.         $this->value = $value; 
24.  
25.     } 
26.  
27.     // 获取实例对应的键 
28.  
29.     public function getKey(){ 
30.  
31.         return array_search($this->value, static::toArray(), true); 
32.  
33.     } 
34.  
35.     // 获取实例对应的值 
36.  
37.     public function getValue() 
38.  
39.     { 
40.  
41.         return $this->value; 
42.  
43.     } 
44.  
45.     // 允许字符串形式输出 
46.  
47.     public function __toString() 
48.  
49.     { 
50.  
51.         return $this->value; 
52.  
53.     } 
54.  
55.     // 验证值是否合法 
56.  
57.     public function isValid($value) 
58.  
59.     { 
60.  
61.       $arr = static::toArray(); 
62.  
63.       return in_array($value, $arr, true); 
64.  
65.     } 
66.  
67.     // 验证键是否合法 
68.  
69.     public function isValidKey($key) 
70.  
71.     { 
72.  
73.       $arr = static::toArray(); 
74.  
75.       return array_key_exists($key, $arr); 
76.  
77.     } 
78.  
79. } 

这样做可避免用户使用非法的枚举类型的值

1. $user->banned = '非法值';  // 可能不会报错 
2.  
3. $yes = new BoolEnum("非法值"); // 将会抛出异常 
4.  
5. $user->banned = $yes; 

或者作为参数类型限定

1. function setUserStatus(BoolEnum $boolEnum){ 
2.  
3.     $user->banned = $boolEnum; 
4.  
5. } 

PHP 作为一门弱类型语言，参数限定的不足会导致很多不可预期的错误发生，通过使用枚举类，我们进一步加强了参数限定的功能，同时，管理枚举类型也更加的方便统一。

Tags: PHP枚举类型

分享到：