Gestion et conception des types d'énumération PHP

L'implémentation de cet article est principalement basée sur le package d'extension myclabs/php-enum.

Aujourd'hui, je vais vous expliquer comment gérer les types d'énumération PHP.

Une méthode courante consiste à utiliser des constantes pour représenter les types d'énumération

const YES = '是';
const NO = '否';

Vous pouvez aller plus loin sur cette base et l'encapsuler dans une classe pour une gestion plus facile

class BoolEnum {
    const YES = '是';
    const NO = '否';
}

Maintenant , nous espérons appeler dynamiquement le type d'énumération correspondant

BoolEnum::YES(); // 是
BoolEnum::NO(); // 否

via des méthodes. Nous pouvons également obtenir des types d'énumération

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

par lots pour implémenter les fonctions répertoriées ci-dessus.

Définissez une classe de base d'énumération de base afin que toutes les classes d'énumération héritent de cette classe de base abstraite.

abstract class Enum
{   
    // 获取所有枚举类型
    public static function toArray(){
        // 通过反射获取常量
        $reflection = new \ReflectionClass(static::class);
        $contants = $reflection->getConstants();
        // 返回对应的常量
        return $contants;
    }
    //  动态调用属性
    public static function __callStatic($name, $arguments)
    {
        $arr = static::toArray();
        if(isset($arr[$name])){
            return $arr[$name];
        }
        throw new \BadMethodCallException("找不到对应的枚举值 {$name}");
    }
}
class BoolEnum extends Enum
{
    const YES = '是';
    const NO = '否';
}

En utilisant la réflexion, tous les types d'énumération peuvent être obtenus. Dans le même temps, la méthode magique peut être utilisée pour appeler dynamiquement des attributs. Il convient de noter ici que la réflexion consomme plus de ressources. Par conséquent, la méthode toArray est reconstruite et une variable de cache est ajoutée pour mettre en cache le type d'énumération obtenu afin d'éviter une utilisation répétée de la réflexion.

abstract class Enum
{   
    protected static $cache = [];
    public static function toArray(){
        $class = static::class;
        // 第一次获取，就通过反射来获取
        if(! isset(static::$cache[$class])){
            $reflection = new \ReflectionClass(static::class);
            static::$cache[$class] = $reflection->getConstants();
        }
        return static::$cache[$class];
    }
}

Envisagez maintenant davantage de scénarios d'utilisation, tels que l'utilisation d'instances pour représenter des types d'énumération spécifiques

$yes = new BoolEnum("是");
echo $yes; // "是"

L'implémentation est la suivante

abstract Enum 
{
    protected $value;
    public function __construct($value)
    {   
        if ($value instanceof static) {
            $value = $value->getValue();
        }
        if(! $this->isValid($value)){
            throw new \UnexpectedValueException("$value 不属于该枚举值" . static::class);
        }
        $this->value = $value;
    }
    // 获取实例对应的键
    public function getKey(){
        return array_search($this->value, static::toArray(), true);
    }
    // 获取实例对应的值
    public function getValue()
    {
        return $this->value;
    }
    // 允许字符串形式输出
    public function __toString()
    {
        return $this->value;
    }
    // 验证值是否合法
    public function isValid($value)
    {
      $arr = static::toArray();
      return in_array($value, $arr, true);
    }
    // 验证键是否合法
    public function isValidKey($key)
    {
      $arr = static::toArray();
      return array_key_exists($key, $arr);
    }
}

Cela peut éviter aux utilisateurs d'utiliser des énumérations illégales. ​​de type

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

ou comme qualification de type de paramètre

function setUserStatus(BoolEnum $boolEnum){
    $user->banned = $boolEnum;
}

PHP est un langage faiblement typé. Des qualifications de paramètre insuffisantes entraîneront de nombreuses erreurs imprévisibles. En utilisant des classes d'énumération, nous La fonction de paramètre. la limitation est encore renforcée et, en même temps, la gestion des types d'énumération est plus pratique et unifiée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!