Home >Backend Development >PHP Tutorial >Detailed explanation of the usage of Enum (enumeration) in php

Detailed explanation of the usage of Enum (enumeration) in php

怪我咯
怪我咯Original
2017-07-14 14:39:0414213browse

An enumeration is a collection of integer constants. Enumerations are very common in daily life.

For example, SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,

SATURDAY representing the week is an enumeration.

The description of the enumeration is similar to the structure and union, and its form is:

enum enumeration name {(enumeration value table)

identifier[=integer constant ],

identifier[=integer constant],

...

identifier[=integer constant],

} enumeration Variable;

If the enumeration is not initialized, that is, when "=integer constant" is omitted, starting from the first identifier, assign 0, 1, 2, .... But when a member in the enumeration value table is assigned a value, the subsequent members will determine their value according to the rule of

plus 1.

The examples in this article describe the usage of Enum (enumeration) in PHP. Share it with everyone for your reference, the details are as follows:

PHP actually has the Enum class library, which requires the installation of the perl extension, so it is not a standard extension of PHP, so the implementation of the code requires the support of the running PHP environment.

(1) Extend the class library SplEnum class. The summary of this class is as follows:

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

Usage example

:

<?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;
}
?>
Output result:

6
Value not a const in enum Month

(2) Customized Enum class library

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

Usage examples are as follows:

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&#39;t exist");
} catch (UnexpectedValueException $e) {
  var_dump($e->getMessage());
}

The output results are as follows:

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"

The above is the detailed content of Detailed explanation of the usage of Enum (enumeration) in php. For more information, please follow other related articles on the PHP Chinese website!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn