Explication détaillée de l'utilisation d'Enum (énumération) en php

Une énumération est une collection de constantes entières. Les énumérations sont très courantes dans la vie quotidienne.

Par exemple, DIMANCHE, LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI,

SAMEDI, qui représente la semaine, est une énumération.

La description de l'énumération est similaire à la structure et à l'union, et sa forme est :

enum nom de l'énumération {(tableau des valeurs de l'énumération)

identifiant [= constante entière ],

identifiant[=constante entière],

...

identifiant[=constante entière],

} enum Variable;

Si l'énumération n'est pas initialisée, c'est-à-dire lorsque "=constante entière" est omis, à partir du premier identifiant, attribuez 0, 1, 2,…. Mais lorsqu'un membre du tableau des valeurs d'énumération se voit attribuer une valeur, les membres suivants détermineront leur valeur selon la règle de

plus 1.

Les exemples de cet article décrivent l'utilisation d'Enum (énumération) en PHP. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

PHP possède en fait la bibliothèque de classes Enum, qui nécessite l'installation de l'extension perl, ce n'est donc pas une extension standard de php, donc l'implémentation du code nécessite la prise en charge de l'environnement php en cours d'exécution.

(1) Étendre la classe SplEnum de la bibliothèque de classes. Le résumé de cette classe est le suivant :

SplEnum extends SplType {
/* Constants */
const NULL default = null ;
/* 方法 */
public array getConstList ([ bool $include_default = false ] )
/* 继承的方法 */
SplType::construct ([ mixed $initial_value [, bool $strict ]] )
}

Exemple d'utilisation

 :

Résultat de sortie :

<?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;
}
?>

(2 ) Personnalisation L'exemple d'utilisation de la bibliothèque de classes Enum

6
Value not a const in enum Month

est le suivant :

<?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&#39;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);
  }
}

Le résultat de sortie est le suivant :

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

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!