PHP y enumeraciones

1149

Sé que PHP no tiene enumeraciones nativas. Pero me he acostumbrado a ellos desde el mundo de Java. Me encantaría usar enumeraciones como una forma de dar valores predefinidos que las características de autocompletado de IDE puedan entender.

Las constantes hacen el truco, pero existe el problema de colisión del espacio de nombres y (o en realidad porque ) son globales. Las matrices no tienen el problema del espacio de nombres, pero son demasiado vagas, pueden sobrescribirse en tiempo de ejecución y los IDE rara vez (¿nunca?) Saben cómo rellenar automáticamente sus claves.

¿Hay alguna solución / solución que utilice comúnmente? ¿Alguien recuerda si los chicos de PHP han tenido alguna idea o decisión sobre las enumeraciones?

Henrik Paul
fuente
1
Creé una función alternativa que enumera las constantes como bit a bit o no. No me di cuenta de que lo preguntaste antes, pero tengo una mejor solución que las variables de clase aquí: stackoverflow.com/questions/3836385/…
NoodleOfDeath
github.com/myclabs/php-enum
Matthieu Napoli
¿Te importaría compartir un poco más sobre el problema de Constantes? "Las constantes hacen el truco, pero existe el problema de colisión del espacio de nombres y (o en realidad porque) son globales".
XuDing
github.com/githubjeka/enum
Evgeniy Tkachenko

Respuestas:

1492

Dependiendo del caso de uso, normalmente usaría algo simple como lo siguiente:

abstract class DaysOfWeek
{
    const Sunday = 0;
    const Monday = 1;
    // etc.
}

$today = DaysOfWeek::Sunday;

Sin embargo, otros casos de uso pueden requerir más validación de constantes y valores. En base a los comentarios a continuación sobre la reflexión, y algunas otras notas , aquí hay un ejemplo ampliado que puede servir mejor para una gama mucho más amplia de casos:

abstract class BasicEnum {
    private static $constCacheArray = NULL;

    private static function getConstants() {
        if (self::$constCacheArray == NULL) {
            self::$constCacheArray = [];
        }
        $calledClass = get_called_class();
        if (!array_key_exists($calledClass, self::$constCacheArray)) {
            $reflect = new ReflectionClass($calledClass);
            self::$constCacheArray[$calledClass] = $reflect->getConstants();
        }
        return self::$constCacheArray[$calledClass];
    }

    public static function isValidName($name, $strict = false) {
        $constants = self::getConstants();

        if ($strict) {
            return array_key_exists($name, $constants);
        }

        $keys = array_map('strtolower', array_keys($constants));
        return in_array(strtolower($name), $keys);
    }

    public static function isValidValue($value, $strict = true) {
        $values = array_values(self::getConstants());
        return in_array($value, $values, $strict);
    }
}

Al crear una clase de enumeración simple que extiende BasicEnum, ahora tiene la capacidad de utilizar métodos para una validación de entrada simple:

abstract class DaysOfWeek extends BasicEnum {
    const Sunday = 0;
    const Monday = 1;
    const Tuesday = 2;
    const Wednesday = 3;
    const Thursday = 4;
    const Friday = 5;
    const Saturday = 6;
}

DaysOfWeek::isValidName('Humpday');                  // false
DaysOfWeek::isValidName('Monday');                   // true
DaysOfWeek::isValidName('monday');                   // true
DaysOfWeek::isValidName('monday', $strict = true);   // false
DaysOfWeek::isValidName(0);                          // false

DaysOfWeek::isValidValue(0);                         // true
DaysOfWeek::isValidValue(5);                         // true
DaysOfWeek::isValidValue(7);                         // false
DaysOfWeek::isValidValue('Friday');                  // false

Como nota al margen, cada vez que uso la reflexión al menos una vez en una clase estática / constante donde los datos no cambiarán (como en una enumeración), guardo en caché los resultados de esas llamadas de reflexión, ya que uso objetos de reflexión nuevos cada vez eventualmente tendrá un impacto notable en el rendimiento (almacenado en una matriz asociativa para múltiples enumeraciones).

Ahora que la mayoría de las personas finalmente se ha actualizado a al menos 5.3, y SplEnumestá disponible, esa es ciertamente una opción viable también, siempre y cuando no le importe la noción tradicionalmente no intuitiva de tener instancias de enumeración reales en toda su base de código. En el ejemplo anterior, BasicEnumy DaysOfWeekno puede ser instanciado en absoluto, ni deberían serlo.

Brian Cline
fuente
70
Yo también uso esto. También puede considerar hacer la clase abstracty final, por lo tanto, no se puede instanciar o extender.
ryeguy
21
Puedes hacer una clase a la vez abstracty final? Sé que en Java esto no está permitido. ¿Puedes hacer eso en php?
corsiKa
20
@ryeguy Parece que no puedes hacer las dos cosas abstract y final. En ese caso, iría por el resumen.
Nicole
45
Sobre resumen o final; Los hago finales y les doy un constructor privado vacío
rael_kid
21
Tenga cuidado con el uso de 0, para no encontrarse con problemas de comparación de falsas no anticipados, por ejemplo, equivalencia con nully amigos en una switchdeclaración. Estado allí.
yitznewton
185

También hay una extensión nativa. El SplEnum

SplEnum ofrece la capacidad de emular y crear objetos de enumeración de forma nativa en PHP.

http://www.php.net/manual/en/class.splenum.php

Atención:

https://www.php.net/manual/en/spl-types.installation.php

La extensión PECL no está incluida en PHP.

Una DLL para esta extensión PECL no está disponible actualmente.

jasie
fuente
44
Aquí hay un ejemplo con el espleno
Nordes
44
Retrocedí, me gusta más cuando puedo ver el enlace. Me da información de contexto.
markus
55
Rodé de nuevo. No quiero que editen el enlace.
markus
66
Ten cuidado al usar esto. Los tipos de SPL son experimentales: "Esta extensión es EXPERIMENTAL. El comportamiento de esta extensión, incluidos los nombres de sus funciones y cualquier otra documentación relacionada con esta extensión, puede cambiar sin previo aviso en una versión futura de PHP. Esta extensión debe usarse bajo su propio riesgo. "
bzeaman
66
SplEnum no está incluido con PHP, necesita la extensión
SPL_Types
46

¿Qué pasa con las constantes de clase?

<?php

class YourClass
{
    const SOME_CONSTANT = 1;

    public function echoConstant()
    {
        echo self::SOME_CONSTANT;
    }
}

echo YourClass::SOME_CONSTANT;

$c = new YourClass;
$c->echoConstant();
Peter Bailey
fuente
Prefiero este enfoque simple
David Lemon el
echoConstantpuede ser reemplazado con __toString. Y luego simplementeecho $c
Justinas
35

La respuesta superior anterior es fantástica. Sin embargo, si tuextend hace de dos maneras diferentes, cualquiera que sea la extensión que se realice primero da como resultado una llamada a las funciones creará el caché. Este caché será utilizado por todas las llamadas posteriores, sin importar la extensión en que las llamadas sean iniciadas por ...

Para resolver esto, reemplace la variable y la primera función con:

private static $constCacheArray = null;

private static function getConstants() {
    if (self::$constCacheArray === null) self::$constCacheArray = array();

    $calledClass = get_called_class();
    if (!array_key_exists($calledClass, self::$constCacheArray)) {
        $reflect = new \ReflectionClass($calledClass);
        self::$constCacheArray[$calledClass] = $reflect->getConstants();
    }

    return self::$constCacheArray[$calledClass];
}
Neil Townsend
fuente
2
Tuve este mismo problema. Brian o alguien con privilegios de edición deben tocarlo en la respuesta aceptada. Lo resolví en mi código usando el método 'static ::' en lugar de 'self ::' en la función getConstants () y volviendo a declarar $ constCache en las enumeraciones secundarias.
Sp3igel
Puede que no sea sexy, pero usar una constante de interfaz puede ser la mejor manera de hacerlo en PHP.
Anthony Rutledge
27

Usé clases con constantes:

class Enum {
    const NAME       = 'aaaa';
    const SOME_VALUE = 'bbbb';
}

print Enum::NAME;
andy.gurin
fuente
27

Yo uso en interfacelugar de class:

interface DaysOfWeek
{
    const Sunday = 0;
    const Monday = 1;
    // etc.
}

var $today = DaysOfWeek::Sunday;
Andi T
fuente
66
class Foo implements DaysOfWeek { }y luego Foo::Sunday... que?
Dan Lugg
3
El autor de la pregunta solicita una solución para dos cosas: espacio de nombres y autocompletado por IDE. Como sugiere la respuesta mejor calificada, la forma más fácil es mediante el uso class(o interface, que es solo una cuestión de preferencia).
Andi T
44
las interfaces se utilizan para imponer la integridad de implementación de la clase, esto está fuera del alcance de una interfaz
user3886650
2
@ user3886650 Las interfaces pueden y fueron / son utilizadas en Java para mantener valores constantes. Por lo tanto, no está obligado a crear una instancia de una clase solo para obtener valores constantes y cualquier IDE ofrece la finalización del código en ellos. Además, si crea una clase que implementa esa interfaz, heredará todas esas constantes, a veces bastante útil.
Alex
@ user3886650 Verdadero, pero en PHP, las interfaces pueden tener constantes. Además, estas constantes de interfaz no pueden ser anuladas implementando clases o sus hijos. En efecto, esta es la mejor respuesta en términos de PHP, porque cualquier cosa que pueda ser anulada no funciona realmente como debería ser una constante. Constante debería significar constante, no a veces (aunque el polimorfismo puede ser útil a veces).
Anthony Rutledge
25

He comentado algunas de las otras respuestas aquí, así que pensé que también me importaría. Al final del día, dado que PHP no admite enumeraciones escritas, puede tomar una de dos formas: cortar las enumeraciones escritas o vivir con el hecho de que son extremadamente difíciles de hackear de manera efectiva.

Prefiero vivir con el hecho, y en su lugar usar el constmétodo que otras respuestas aquí han usado de una forma u otra:

abstract class Enum
{

    const NONE = null;

    final private function __construct()
    {
        throw new NotSupportedException(); // 
    }

    final private function __clone()
    {
        throw new NotSupportedException();
    }

    final public static function toArray()
    {
        return (new ReflectionClass(static::class))->getConstants();
    }

    final public static function isValid($value)
    {
        return in_array($value, static::toArray());
    }

}

Un ejemplo de enumeración:

final class ResponseStatusCode extends Enum
{

    const OK                         = 200;
    const CREATED                    = 201;
    const ACCEPTED                   = 202;
    // ...
    const SERVICE_UNAVAILABLE        = 503;
    const GATEWAY_TIME_OUT           = 504;
    const HTTP_VERSION_NOT_SUPPORTED = 505;

}

El uso Enumcomo una clase base desde la que se extienden todas las demás enumeraciones permite métodos auxiliares, como toArray, isValidetc. Para mí, las enumeraciones escritas ( y la gestión de sus instancias ) terminan siendo demasiado desordenadas.


Hipotético

Si , existía un __getStaticmétodo mágico ( y preferiblemente un __equalsmétodo mágico también ), gran parte de esto podría mitigarse con una especie de patrón multitonal.

( Lo siguiente es hipotético; no funcionará, aunque quizás algún día lo haga )

final class TestEnum
{

    private static $_values = [
        'FOO' => 1,
        'BAR' => 2,
        'QUX' => 3,
    ];
    private static $_instances = [];

    public static function __getStatic($name)
    {
        if (isset(static::$_values[$name]))
        {
            if (empty(static::$_instances[$name]))
            {
                static::$_instances[$name] = new static($name);
            }
            return static::$_instances[$name];
        }
        throw new Exception(sprintf('Invalid enumeration value, "%s"', $name));
    }

    private $_value;

    public function __construct($name)
    {
        $this->_value = static::$_values[$name];
    }

    public function __equals($object)
    {
        if ($object instanceof static)
        {
            return $object->_value === $this->_value;
        }
        return $object === $this->_value;
    }

}

$foo = TestEnum::$FOO; // object(TestEnum)#1 (1) {
                       //   ["_value":"TestEnum":private]=>
                       //   int(1)
                       // }

$zap = TestEnum::$ZAP; // Uncaught exception 'Exception' with message
                       // 'Invalid enumeration member, "ZAP"'

$qux = TestEnum::$QUX;
TestEnum::$QUX == $qux; // true
'hello world!' == $qux; // false
Dan Lugg
fuente
Realmente me gusta la simplicidad de esta respuesta. Es el tipo de cosas a las que puede volver más tarde y comprender rápidamente cómo funciona sin hacer que parezca que hizo algún tipo de enfoque pirateado. Una pena que no tenga más votos.
Reactgular
23

Bueno, para un simple java como enum en php, uso:

class SomeTypeName {
    private static $enum = array(1 => "Read", 2 => "Write");

    public function toOrdinal($name) {
        return array_search($name, self::$enum);
    }

    public function toString($ordinal) {
        return self::$enum[$ordinal];
    }
}

Y para llamarlo:

SomeTypeName::toOrdinal("Read");
SomeTypeName::toString(1);

Pero soy un principiante de PHP, luchando con la sintaxis, por lo que esta podría no ser la mejor manera. Experimenté algunos con Constantes de clase, usando Reflection para obtener el nombre constante de su valor, podría ser más ordenado.

aelg
fuente
Buena respuesta, la mayoría de las otras respuestas están usando clases. Sin embargo, no puedes tener clases anidadas.
Keyo
Esto tiene la ventaja de poder recorrer los valores con foreach. Y en detrimento de que no se capture un valor ilegal.
Bob Stein
2
Sin embargo, no se completó automáticamente en el IDE, por lo que estimularía las conjeturas. Las constantes permitirían la finalización automática, suena mejor.
KrekkieD
19

Cuatro años después me encontré con esto nuevamente. Mi enfoque actual es este, ya que permite completar el código en el IDE, así como la seguridad de tipo:

Clase base:

abstract class TypedEnum
{
    private static $_instancedValues;

    private $_value;
    private $_name;

    private function __construct($value, $name)
    {
        $this->_value = $value;
        $this->_name = $name;
    }

    private static function _fromGetter($getter, $value)
    {
        $reflectionClass = new ReflectionClass(get_called_class());
        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC | ReflectionMethod::IS_PUBLIC);    
        $className = get_called_class();

        foreach($methods as $method)
        {
            if ($method->class === $className)
            {
                $enumItem = $method->invoke(null);

                if ($enumItem instanceof $className && $enumItem->$getter() === $value)
                {
                    return $enumItem;
                }
            }
        }

        throw new OutOfRangeException();
    }

    protected static function _create($value)
    {
        if (self::$_instancedValues === null)
        {
            self::$_instancedValues = array();
        }

        $className = get_called_class();

        if (!isset(self::$_instancedValues[$className]))
        {
            self::$_instancedValues[$className] = array();
        }

        if (!isset(self::$_instancedValues[$className][$value]))
        {
            $debugTrace = debug_backtrace();
            $lastCaller = array_shift($debugTrace);

            while ($lastCaller['class'] !== $className && count($debugTrace) > 0)
            {
                $lastCaller = array_shift($debugTrace);
            }

            self::$_instancedValues[$className][$value] = new static($value, $lastCaller['function']);
        }

        return self::$_instancedValues[$className][$value];
    }

    public static function fromValue($value)
    {
        return self::_fromGetter('getValue', $value);
    }

    public static function fromName($value)
    {
        return self::_fromGetter('getName', $value);
    }

    public function getValue()
    {
        return $this->_value;
    }

    public function getName()
    {
        return $this->_name;
    }
}

Ejemplo de enumeración:

final class DaysOfWeek extends TypedEnum
{
    public static function Sunday() { return self::_create(0); }    
    public static function Monday() { return self::_create(1); }
    public static function Tuesday() { return self::_create(2); }   
    public static function Wednesday() { return self::_create(3); }
    public static function Thursday() { return self::_create(4); }  
    public static function Friday() { return self::_create(5); }
    public static function Saturday() { return self::_create(6); }      
}

Ejemplo de uso:

function saveEvent(DaysOfWeek $weekDay, $comment)
{
    // store week day numeric value and comment:
    $myDatabase->save('myeventtable', 
       array('weekday_id' => $weekDay->getValue()),
       array('comment' => $comment));
}

// call the function, note: DaysOfWeek::Monday() returns an object of type DaysOfWeek
saveEvent(DaysOfWeek::Monday(), 'some comment');

Tenga en cuenta que todas las instancias de la misma entrada enum son iguales:

$monday1 = DaysOfWeek::Monday();
$monday2 = DaysOfWeek::Monday();
$monday1 === $monday2; // true

También puede usarlo dentro de una declaración de cambio:

function getGermanWeekDayName(DaysOfWeek $weekDay)
{
    switch ($weekDay)
    {
        case DaysOfWeek::Monday(): return 'Montag';
        case DaysOfWeek::Tuesday(): return 'Dienstag';
        // ...
}

También puede crear una entrada de enumeración por nombre o valor:

$monday = DaysOfWeek::fromValue(2);
$tuesday = DaysOfWeek::fromName('Tuesday');

O simplemente puede obtener el nombre (es decir, el nombre de la función) de una entrada enum existente:

$wednesday = DaysOfWeek::Wednesday()
echo $wednesDay->getName(); // Wednesday
Buck Fixing
fuente
+1 para un constructor privado. No haría una clase abstracta auxiliar, solo una clase simple, un constructor privado y algo deconst Monday = DaysOfWeek('Monday');
Kangur
9

Encontré esta biblioteca en github y creo que proporciona una alternativa muy decente a las respuestas aquí.

Implementación PHP Enum inspirada en SplEnum

  • Puede escribir una pista: function setAction(Action $action) {
  • Puede enriquecer la enumeración con métodos (por ejemplo format,parse , ...)
  • Puede extender la enumeración para agregar nuevos valores (haga su enumeración finalpara evitarlo)
  • Puede obtener una lista de todos los valores posibles (ver más abajo)

Declaración

<?php
use MyCLabs\Enum\Enum;

/**
 * Action enum
 */
class Action extends Enum
{
    const VIEW = 'view';
    const EDIT = 'edit';
}

Uso

<?php
$action = new Action(Action::VIEW);

// or
$action = Action::VIEW();

valores de enumeración de tipo de pista:

<?php
function setAction(Action $action) {
    // ...
}
Songo
fuente
1
Esta es la respuesta correcta (por ahora, hasta que enumse agregue en PHP 7.x) porque permite sugerencias de tipo.
Tobia
1
Esto no solo permite sugerencias de tipo, sino que, debido a la __toString()magia, te permite hacer lo que generalmente quieres con enumeraciones: úsalas en una declaración switcho if, comparándolas directamente con los valores de los consts. El mejor enfoque por debajo del soporte de enumeración nativa, IMO.
LinusR
7

Si necesita usar enumeraciones que sean globalmente únicas (es decir, incluso al comparar elementos entre diferentes enumeraciones) y que sean fáciles de usar, no dude en usar el siguiente código. También agregué algunos métodos que encuentro útiles. Encontrará ejemplos en los comentarios en la parte superior del código.

<?php

/**
 * Class Enum
 * 
 * @author Christopher Fox <[email protected]>
 *
 * @version 1.0
 *
 * This class provides the function of an enumeration.
 * The values of Enum elements are unique (even between different Enums)
 * as you would expect them to be.
 *
 * Constructing a new Enum:
 * ========================
 *
 * In the following example we construct an enum called "UserState"
 * with the elements "inactive", "active", "banned" and "deleted".
 * 
 * <code>
 * Enum::Create('UserState', 'inactive', 'active', 'banned', 'deleted');
 * </code>
 *
 * Using Enums:
 * ============
 *
 * The following example demonstrates how to compare two Enum elements
 *
 * <code>
 * var_dump(UserState::inactive == UserState::banned); // result: false
 * var_dump(UserState::active == UserState::active); // result: true
 * </code>
 *
 * Special Enum methods:
 * =====================
 *
 * Get the number of elements in an Enum:
 *
 * <code>
 * echo UserState::CountEntries(); // result: 4
 * </code>
 *
 * Get a list with all elements of the Enum:
 *
 * <code>
 * $allUserStates = UserState::GetEntries();
 * </code>
 *
 * Get a name of an element:
 *
 * <code>
 * echo UserState::GetName(UserState::deleted); // result: deleted
 * </code>
 *
 * Get an integer ID for an element (e.g. to store as a value in a database table):
 * This is simply the index of the element (beginning with 1).
 * Note that this ID is only unique for this Enum but now between different Enums.
 *
 * <code>
 * echo UserState::GetDatabaseID(UserState::active); // result: 2
 * </code>
 */
class Enum
{

    /**
     * @var Enum $instance The only instance of Enum (Singleton)
     */
    private static $instance;

    /**
     * @var array $enums    An array of all enums with Enum names as keys
     *          and arrays of element names as values
     */
    private $enums;

    /**
     * Constructs (the only) Enum instance
     */
    private function __construct()
    {
        $this->enums = array();
    }

    /**
     * Constructs a new enum
     *
     * @param string $name The class name for the enum
     * @param mixed $_ A list of strings to use as names for enum entries
     */
    public static function Create($name, $_)
    {
        // Create (the only) Enum instance if this hasn't happened yet
        if (self::$instance===null)
        {
            self::$instance = new Enum();
        }

        // Fetch the arguments of the function
        $args = func_get_args();
        // Exclude the "name" argument from the array of function arguments,
        // so only the enum element names remain in the array
        array_shift($args);
        self::$instance->add($name, $args);
    }

    /**
     * Creates an enumeration if this hasn't happened yet
     * 
     * @param string $name The class name for the enum
     * @param array $fields The names of the enum elements
     */
    private function add($name, $fields)
    {
        if (!array_key_exists($name, $this->enums))
        {
            $this->enums[$name] = array();

            // Generate the code of the class for this enumeration
            $classDeclaration =     "class " . $name . " {\n"
                        . "private static \$name = '" . $name . "';\n"
                        . $this->getClassConstants($name, $fields)
                        . $this->getFunctionGetEntries($name)
                        . $this->getFunctionCountEntries($name)
                        . $this->getFunctionGetDatabaseID()
                        . $this->getFunctionGetName()
                        . "}";

            // Create the class for this enumeration
            eval($classDeclaration);
        }
    }

    /**
     * Returns the code of the class constants
     * for an enumeration. These are the representations
     * of the elements.
     * 
     * @param string $name The class name for the enum
     * @param array $fields The names of the enum elements
     *
     * @return string The code of the class constants
     */
    private function getClassConstants($name, $fields)
    {
        $constants = '';

        foreach ($fields as $field)
        {
            // Create a unique ID for the Enum element
            // This ID is unique because class and variables
            // names can't contain a semicolon. Therefore we
            // can use the semicolon as a separator here.
            $uniqueID = $name . ";" . $field;
            $constants .=   "const " . $field . " = '". $uniqueID . "';\n";
            // Store the unique ID
            array_push($this->enums[$name], $uniqueID);
        }

        return $constants;
    }

    /**
     * Returns the code of the function "GetEntries()"
     * for an enumeration
     * 
     * @param string $name The class name for the enum
     *
     * @return string The code of the function "GetEntries()"
     */
    private function getFunctionGetEntries($name) 
    {
        $entryList = '';        

        // Put the unique element IDs in single quotes and
        // separate them with commas
        foreach ($this->enums[$name] as $key => $entry)
        {
            if ($key > 0) $entryList .= ',';
            $entryList .= "'" . $entry . "'";
        }

        return  "public static function GetEntries() { \n"
            . " return array(" . $entryList . ");\n"
            . "}\n";
    }

    /**
     * Returns the code of the function "CountEntries()"
     * for an enumeration
     * 
     * @param string $name The class name for the enum
     *
     * @return string The code of the function "CountEntries()"
     */
    private function getFunctionCountEntries($name) 
    {
        // This function will simply return a constant number (e.g. return 5;)
        return  "public static function CountEntries() { \n"
            . " return " . count($this->enums[$name]) . ";\n"
            . "}\n";
    }

    /**
     * Returns the code of the function "GetDatabaseID()"
     * for an enumeration
     * 
     * @return string The code of the function "GetDatabaseID()"
     */
    private function getFunctionGetDatabaseID()
    {
        // Check for the index of this element inside of the array
        // of elements and add +1
        return  "public static function GetDatabaseID(\$entry) { \n"
            . "\$key = array_search(\$entry, self::GetEntries());\n"
            . " return \$key + 1;\n"
            . "}\n";
    }

    /**
     * Returns the code of the function "GetName()"
     * for an enumeration
     *
     * @return string The code of the function "GetName()"
     */
    private function getFunctionGetName()
    {
        // Remove the class name from the unique ID 
        // and return this value (which is the element name)
        return  "public static function GetName(\$entry) { \n"
            . "return substr(\$entry, strlen(self::\$name) + 1 , strlen(\$entry));\n"
            . "}\n";
    }

}


?>
Christopher Fox
fuente
1
Me gusta mucho esto. Sin embargo, una de las principales quejas es la capacidad del IDE de recoger los valores para autocompletar. No estoy seguro de que esto pueda hacerlo sin un complemento personalizado para el IDE. No es que no se pudiera hacer, solo tomaría un poco de trabajo.
corsiKa
2
¿Usar eval()solo para poder declarar el nuevo tiempo de ejecución de Enums? Eek No lo estoy sintiendo. ¿Cómo evita que otras clases creen una clase Enum incorrecta antes de definir la correcta? ¿No se conocen las enumeraciones antes del tiempo de ejecución? Y como implicaba @corsiKa, no hay autocompletado IDE. El único beneficio que veo es la codificación perezosa.
KrekkieD
7

También me gustan las enumeraciones de Java y por esta razón escribo mis enumeraciones de esta manera, creo que este es el comportamiento más similar al de las enumeraciones de Java, por supuesto, si algunos quieren usar más métodos de Java, escríbalo aquí, o en clase abstracta pero la idea central está incrustada en el código a continuación


class FruitsEnum {

    static $APPLE = null;
    static $ORANGE = null;

    private $value = null;

    public static $map;

    public function __construct($value) {
        $this->value = $value;
    }

    public static function init () {
        self::$APPLE  = new FruitsEnum("Apple");
        self::$ORANGE = new FruitsEnum("Orange");
        //static map to get object by name - example Enum::get("INIT") - returns Enum::$INIT object;
        self::$map = array (
            "Apple" => self::$APPLE,
            "Orange" => self::$ORANGE
        );
    }

    public static function get($element) {
        if($element == null)
            return null;
        return self::$map[$element];
    }

    public function getValue() {
        return $this->value;
    }

    public function equals(FruitsEnum $element) {
        return $element->getValue() == $this->getValue();
    }

    public function __toString () {
        return $this->value;
    }
}
FruitsEnum::init();

var_dump(FruitsEnum::$APPLE->equals(FruitsEnum::$APPLE)); //true
var_dump(FruitsEnum::$APPLE->equals(FruitsEnum::$ORANGE)); //false
var_dump(FruitsEnum::$APPLE instanceof FruitsEnum); //true
var_dump(FruitsEnum::get("Apple")->equals(FruitsEnum::$APPLE)); //true - enum from string
var_dump(FruitsEnum::get("Apple")->equals(FruitsEnum::get("Orange"))); //false
usuario667540
fuente
3
Estoy haciendo casi lo mismo, aunque con dos pequeñas adiciones: he ocultado los valores estáticos detrás de los captadores estáticos. Una de las razones es que prefiero visualmente FruitsEnum::Apple()más FruitsEnum::$Apple, pero la razón más importante es evitar que cualquier otro de ajuste $APPLE, rompiendo así la enumeración para toda la aplicación. El otro es un indicador estático privado simple $initializedque asegura que las llamadas se init()vuelvan no operativas después de llamar por primera vez (para que nadie pueda meterse con eso tampoco).
Martin Ender
Me gustó Martin. .init()es raro, y no me importa el enfoque getter.
Sebas
7
abstract class Enumeration
{
    public static function enum() 
    {
        $reflect = new ReflectionClass( get_called_class() );
        return $reflect->getConstants();
    }
}


class Test extends Enumeration
{
    const A = 'a';
    const B = 'b';    
}


foreach (Test::enum() as $key => $value) {
    echo "$key -> $value<br>";
}
jglatre
fuente
6

Puede ser tan simple como

enum DaysOfWeek {
    Sunday,
    Monday,
    // ...
}

en el futuro.

PHP RFC: Tipos enumerados

mykhal
fuente
FYI a partir de 7.1 todavía no está aquí
toddmo
5

La solución más común que he visto para enum's en PHP ha sido crear una clase enum genérica y luego extenderla. Puedes echar un vistazo a esto .

ACTUALIZACIÓN: Alternativamente, encontré esto en phpclasses.org.

Noah Goodrich
fuente
1
Aunque la implementación es ingeniosa y probablemente haría el trabajo, la desventaja de esto es que los IDEs probablemente no saben cómo rellenar automáticamente las enumeraciones. No pude inspeccionar el de phpclasses.org, porque quería que me registrara.
Henrik Paul el
5

Aquí hay una biblioteca github para manejar enumeraciones de tipo seguro en php:

Esta biblioteca maneja la generación de clases, el almacenamiento en caché de clases e implementa el patrón de diseño de enumeración segura de tipo, con varios métodos auxiliares para tratar con enumeraciones, como recuperar un ordinal para ordenar enumeraciones, o recuperar un valor binario, para combinaciones de enumeraciones.

El código generado utiliza un archivo de plantilla php antiguo simple, que también es configurable, por lo que puede proporcionar su propia plantilla.

Es una prueba completa cubierta con phpunit.

php-enums en github (no dude en bifurcar)

Uso: (@ver use.php, o pruebas unitarias para más detalles)

<?php
//require the library
require_once __DIR__ . '/src/Enum.func.php';

//if you don't have a cache directory, create one
@mkdir(__DIR__ . '/cache');
EnumGenerator::setDefaultCachedClassesDir(__DIR__ . '/cache');

//Class definition is evaluated on the fly:
Enum('FruitsEnum', array('apple' , 'orange' , 'rasberry' , 'bannana'));

//Class definition is cached in the cache directory for later usage:
Enum('CachedFruitsEnum', array('apple' , 'orange' , 'rasberry' , 'bannana'), '\my\company\name\space', true);

echo 'FruitsEnum::APPLE() == FruitsEnum::APPLE(): ';
var_dump(FruitsEnum::APPLE() == FruitsEnum::APPLE()) . "\n";

echo 'FruitsEnum::APPLE() == FruitsEnum::ORANGE(): ';
var_dump(FruitsEnum::APPLE() == FruitsEnum::ORANGE()) . "\n";

echo 'FruitsEnum::APPLE() instanceof Enum: ';
var_dump(FruitsEnum::APPLE() instanceof Enum) . "\n";

echo 'FruitsEnum::APPLE() instanceof FruitsEnum: ';
var_dump(FruitsEnum::APPLE() instanceof FruitsEnum) . "\n";

echo "->getName()\n";
foreach (FruitsEnum::iterator() as $enum)
{
  echo "  " . $enum->getName() . "\n";
}

echo "->getValue()\n";
foreach (FruitsEnum::iterator() as $enum)
{
  echo "  " . $enum->getValue() . "\n";
}

echo "->getOrdinal()\n";
foreach (CachedFruitsEnum::iterator() as $enum)
{
  echo "  " . $enum->getOrdinal() . "\n";
}

echo "->getBinary()\n";
foreach (CachedFruitsEnum::iterator() as $enum)
{
  echo "  " . $enum->getBinary() . "\n";
}

Salida:

FruitsEnum::APPLE() == FruitsEnum::APPLE(): bool(true)
FruitsEnum::APPLE() == FruitsEnum::ORANGE(): bool(false)
FruitsEnum::APPLE() instanceof Enum: bool(true)
FruitsEnum::APPLE() instanceof FruitsEnum: bool(true)
->getName()
  APPLE
  ORANGE
  RASBERRY
  BANNANA
->getValue()
  apple
  orange
  rasberry
  bannana
->getValue() when values have been specified
  pig
  dog
  cat
  bird
->getOrdinal()
  1
  2
  3
  4
->getBinary()
  1
  2
  4
  8
zanshine
fuente
4

He optado por utilizar el siguiente enfoque, ya que me da la capacidad de tener seguridad de tipo para los parámetros de función, autocompletar en NetBeans y buen rendimiento. Lo único que no me gusta demasiado es que tienes que llamar [extended class name]::enumerate();después de definir la clase.

abstract class Enum {

    private $_value;

    protected function __construct($value) {
        $this->_value = $value;
    }

    public function __toString() {
        return (string) $this->_value;
    }

    public static function enumerate() {
        $class = get_called_class();
        $ref = new ReflectionClass($class);
        $statics = $ref->getStaticProperties();
        foreach ($statics as $name => $value) {
            $ref->setStaticPropertyValue($name, new $class($value));
        }
    }
}

class DaysOfWeek extends Enum {
    public static $MONDAY = 0;
    public static $SUNDAY = 1;
    // etc.
}
DaysOfWeek::enumerate();

function isMonday(DaysOfWeek $d) {
    if ($d == DaysOfWeek::$MONDAY) {
        return true;
    } else {
        return false;
    }
}

$day = DaysOfWeek::$MONDAY;
echo (isMonday($day) ? "bummer it's monday" : "Yay! it's not monday");
Brian Fisher
fuente
Nada le impide redefinir los valores de enumeración:DaysOfWeek::$MONDAY = 3;
KrekkieD
@BrianFisher, sé que es un poco tarde ahora, pero, si no te gusta llamar [extended class name]::enumerate();después de la definición, ¿por qué no lo haces en la construcción?
Can O 'Spam
4

Mi definición de clase Enum a continuación está fuertemente tipada y es muy natural de usar y definir.

Definición:

class Fruit extends Enum {
    static public $APPLE = 1;
    static public $ORANGE = 2;
}
Fruit::initialize(); //Can also be called in autoloader

Cambiar Enum

$myFruit = Fruit::$APPLE;

switch ($myFruit) {
    case Fruit::$APPLE  : echo "I like apples\n";  break;
    case Fruit::$ORANGE : echo "I hate oranges\n"; break;
}

>> I like apples

Pase Enum como parámetro (fuertemente tipado)

/** Function only accepts Fruit enums as input**/
function echoFruit(Fruit $fruit) {
    echo $fruit->getName().": ".$fruit->getValue()."\n";
}

/** Call function with each Enum value that Fruit has */
foreach (Fruit::getList() as $fruit) {
    echoFruit($fruit);
}

//Call function with Apple enum
echoFruit(Fruit::$APPLE)

//Will produce an error. This solution is strongly typed
echoFruit(2);

>> APPLE: 1
>> ORANGE: 2
>> APPLE: 1
>> Argument 1 passed to echoFruit() must be an instance of Fruit, integer given

Echo Enum como cuerda

echo "I have an $myFruit\n";

>> I have an APPLE

Consigue Enum por entero

$myFruit = Fruit::getByValue(2);

echo "Now I have an $myFruit\n";

>> Now I have an ORANGE

Obtenga Enum por nombre

$myFruit = Fruit::getByName("APPLE");

echo "But I definitely prefer an $myFruit\n\n";

>> But I definitely prefer an APPLE

La clase de Enum:

/**
 * @author Torge Kummerow
 */
class Enum {

    /**
     * Holds the values for each type of Enum
     */
    static private $list = array();

    /**
     * Initializes the enum values by replacing the number with an instance of itself
     * using reflection
     */
    static public function initialize() {
        $className = get_called_class();
        $class = new ReflectionClass($className);
        $staticProperties = $class->getStaticProperties();

        self::$list[$className] = array();

        foreach ($staticProperties as $propertyName => &$value) {
            if ($propertyName == 'list')
                continue;

            $enum = new $className($propertyName, $value);
            $class->setStaticPropertyValue($propertyName, $enum);
            self::$list[$className][$propertyName] = $enum;
        } unset($value);
    }


    /**
     * Gets the enum for the given value
     *
     * @param integer $value
     * @throws Exception
     *
     * @return Enum
     */
    static public function getByValue($value) {
        $className = get_called_class();
        foreach (self::$list[$className] as $propertyName=>&$enum) {
            /* @var $enum Enum */
            if ($enum->value == $value)
                return $enum;
        } unset($enum);

        throw new Exception("No such enum with value=$value of type ".get_called_class());
    }

    /**
     * Gets the enum for the given name
     *
     * @param string $name
     * @throws Exception
     *
     * @return Enum
     */
    static public function getByName($name) {
        $className = get_called_class();
        if (array_key_exists($name, static::$list[$className]))
            return self::$list[$className][$name];

        throw new Exception("No such enum ".get_called_class()."::\$$name");
    }


    /**
     * Returns the list of all enum variants
     * @return Array of Enum
     */
    static public function getList() {
        $className = get_called_class();
        return self::$list[$className];
    }


    private $name;
    private $value;

    public function __construct($name, $value) {
        $this->name = $name;
        $this->value = $value;
    }

    public function __toString() {
        return $this->name;
    }

    public function getValue() {
        return $this->value;
    }

    public function getName() {
        return $this->name;
    }

}

Adición

Por supuesto, también puede agregar comentarios para IDEs

class Fruit extends Enum {

    /**
     * This comment is for autocomplete support in common IDEs
     * @var Fruit A yummy apple
     */
    static public $APPLE = 1;

    /**
     * This comment is for autocomplete support in common IDEs
     * @var Fruit A sour orange
     */
    static public $ORANGE = 2;
}

//This can also go to the autoloader if available.
Fruit::initialize();
Torge
fuente
4

Me doy cuenta de que este es un hilo muy, muy antiguo, pero pensé en esto y quise saber qué pensaba la gente.

Notas: Estaba jugando con esto y me di cuenta de que si solo modificaba la __call()función, podría acercarse aún más a la real enums. La __call()función maneja todas las llamadas a funciones desconocidas. Entonces, digamos que quieres hacer tres enumsRED_LIGHT, YELLOW_LIGHT y GREEN_LIGHT. Puede hacerlo ahora simplemente haciendo lo siguiente:

$c->RED_LIGHT();
$c->YELLOW_LIGHT();
$c->GREEN_LIGHT();

Una vez definido, todo lo que tiene que hacer es llamarlos nuevamente para obtener los valores:

echo $c->RED_LIGHT();
echo $c->YELLOW_LIGHT();
echo $c->GREEN_LIGHT();

y deberías obtener 0, 1 y 2. ¡Diviértete! Esto también está ahora en GitHub.

Actualización: lo hice para que ahora se utilicen las funciones __get()y __set(). Esto le permite no tener que llamar a una función a menos que lo desee. En cambio, ahora solo puedes decir:

$c->RED_LIGHT;
$c->YELLOW_LIGHT;
$c->GREEN_LIGHT;

Tanto para la creación como para la obtención de los valores. Debido a que las variables no se han definido inicialmente, la __get()función se llama (porque no hay un valor especificado) que ve que la entrada en la matriz no se ha realizado. Por lo tanto, realiza la entrada, le asigna el último valor dado más uno (+1), incrementa la última variable de valor y devuelve VERDADERO. Si establece el valor:

$c->RED_LIGHT = 85;

Luego __set()se llama a la función y el último valor se establece en el nuevo valor más uno (+1). Así que ahora tenemos una forma bastante buena de hacer enumeraciones y se pueden crear sobre la marcha.

<?php
################################################################################
#   Class ENUMS
#
#       Original code by Mark Manning.
#       Copyrighted (c) 2015 by Mark Manning.
#       All rights reserved.
#
#       This set of code is hereby placed into the free software universe
#       via the GNU greater license thus placing it under the Copyleft
#       rules and regulations with the following modifications:
#
#       1. You may use this work in any other work.  Commercial or otherwise.
#       2. You may make as much money as you can with it.
#       3. You owe me nothing except to give me a small blurb somewhere in
#           your program or maybe have pity on me and donate a dollar to
#           [email protected].  :-)
#
#   Blurb:
#
#       PHP Class Enums by Mark Manning (markem-AT-sim1-DOT-us).
#       Used with permission.
#
#   Notes:
#
#       VIM formatting.  Set tabs to four(4) spaces.
#
################################################################################
class enums
{
    private $enums;
    private $clear_flag;
    private $last_value;

################################################################################
#   __construct(). Construction function.  Optionally pass in your enums.
################################################################################
function __construct()
{
    $this->enums = array();
    $this->clear_flag = false;
    $this->last_value = 0;

    if( func_num_args() > 0 ){
        return $this->put( func_get_args() );
        }

    return true;
}
################################################################################
#   put(). Insert one or more enums.
################################################################################
function put()
{
    $args = func_get_args();
#
#   Did they send us an array of enums?
#   Ex: $c->put( array( "a"=>0, "b"=>1,...) );
#   OR  $c->put( array( "a", "b", "c",... ) );
#
    if( is_array($args[0]) ){
#
#   Add them all in
#
        foreach( $args[0] as $k=>$v ){
#
#   Don't let them change it once it is set.
#   Remove the IF statement if you want to be able to modify the enums.
#
            if( !isset($this->enums[$k]) ){
#
#   If they sent an array of enums like this: "a","b","c",... then we have to
#   change that to be "A"=>#. Where "#" is the current count of the enums.
#
                if( is_numeric($k) ){
                    $this->enums[$v] = $this->last_value++;
                    }
#
#   Else - they sent "a"=>"A", "b"=>"B", "c"=>"C"...
#
                    else {
                        $this->last_value = $v + 1;
                        $this->enums[$k] = $v;
                        }
                }
            }
        }
#
#   Nope!  Did they just sent us one enum?
#
        else {
#
#   Is this just a default declaration?
#   Ex: $c->put( "a" );
#
            if( count($args) < 2 ){
#
#   Again - remove the IF statement if you want to be able to change the enums.
#
                if( !isset($this->enums[$args[0]]) ){
                    $this->enums[$args[0]] = $this->last_value++;
                    }
#
#   No - they sent us a regular enum
#   Ex: $c->put( "a", "This is the first enum" );
#
                    else {
#
#   Again - remove the IF statement if you want to be able to change the enums.
#
                        if( !isset($this->enums[$args[0]]) ){
                            $this->last_value = $args[1] + 1;
                            $this->enums[$args[0]] = $args[1];
                            }
                        }
                }
            }

    return true;
}
################################################################################
#   get(). Get one or more enums.
################################################################################
function get()
{
    $num = func_num_args();
    $args = func_get_args();
#
#   Is this an array of enums request? (ie: $c->get(array("a","b","c"...)) )
#
    if( is_array($args[0]) ){
        $ary = array();
        foreach( $args[0] as $k=>$v ){
            $ary[$v] = $this->enums[$v];
            }

        return $ary;
        }
#
#   Is it just ONE enum they want? (ie: $c->get("a") )
#
        else if( ($num > 0) && ($num < 2) ){
            return $this->enums[$args[0]];
            }
#
#   Is it a list of enums they want? (ie: $c->get( "a", "b", "c"...) )
#
        else if( $num > 1 ){
            $ary = array();
            foreach( $args as $k=>$v ){
                $ary[$v] = $this->enums[$v];
                }

            return $ary;
            }
#
#   They either sent something funky or nothing at all.
#
    return false;
}
################################################################################
#   clear(). Clear out the enum array.
#       Optional.  Set the flag in the __construct function.
#       After all, ENUMS are supposed to be constant.
################################################################################
function clear()
{
    if( $clear_flag ){
        unset( $this->enums );
        $this->enums = array();
        }

    return true;
}
################################################################################
#   __call().  In case someone tries to blow up the class.
################################################################################
function __call( $name, $arguments )
{
    if( isset($this->enums[$name]) ){ return $this->enums[$name]; }
        else if( !isset($this->enums[$name]) && (count($arguments) > 0) ){
            $this->last_value = $arguments[0] + 1;
            $this->enums[$name] = $arguments[0];
            return true;
            }
        else if( !isset($this->enums[$name]) && (count($arguments) < 1) ){
            $this->enums[$name] = $this->last_value++;
            return true;
            }

    return false;
}
################################################################################
#   __get(). Gets the value.
################################################################################
function __get($name)
{
    if( isset($this->enums[$name]) ){ return $this->enums[$name]; }
        else if( !isset($this->enums[$name]) ){
            $this->enums[$name] = $this->last_value++;
            return true;
            }

    return false;
}
################################################################################
#   __set().  Sets the value.
################################################################################
function __set( $name, $value=null )
{
    if( isset($this->enums[$name]) ){ return false; }
        else if( !isset($this->enums[$name]) && !is_null($value) ){
            $this->last_value = $value + 1;
            $this->enums[$name] = $value;
            return true;
            }
        else if( !isset($this->enums[$name]) && is_null($value) ){
            $this->enums[$name] = $this->last_value++;
            return true;
            }

    return false;
}
################################################################################
#   __destruct().  Deconstruct the class.  Remove the list of enums.
################################################################################
function __destruct()
{
    unset( $this->enums );
    $this->enums = null;

    return true;
}

}
#
#   Test code
#
#   $c = new enums();
#   $c->RED_LIGHT(85);
#   $c->YELLOW_LIGHT = 23;
#   $c->GREEN_LIGHT;
#
#   echo $c->RED_LIGHT . "\n";
#   echo $c->YELLOW_LIGHT . "\n";
#   echo $c->GREEN_LIGHT . "\n";

?>
Mark Manning
fuente
3

Sé que este es un hilo antiguo, sin embargo, ninguna de las soluciones que he visto realmente se parecía a enumeraciones, ya que casi todas las soluciones alternativas requieren que asigne valores manualmente a los elementos de enumeración, o requiere que pase una matriz de claves de enumeración a un función. Entonces creé mi propia solución para esto.

Para crear una clase enum usando mi solución, simplemente puede extender esta clase Enum a continuación, crear un grupo de variables estáticas (no es necesario inicializarlas) y hacer una llamada a yourEnumClass :: init () justo debajo de la definición de su clase enum .

editar: esto solo funciona en php> = 5.3, pero probablemente también se pueda modificar para que funcione en versiones anteriores

/**
 * A base class for enums. 
 * 
 * This class can be used as a base class for enums. 
 * It can be used to create regular enums (incremental indices), but it can also be used to create binary flag values.
 * To create an enum class you can simply extend this class, and make a call to <yourEnumClass>::init() before you use the enum.
 * Preferably this call is made directly after the class declaration. 
 * Example usages:
 * DaysOfTheWeek.class.php
 * abstract class DaysOfTheWeek extends Enum{
 *      static $MONDAY = 1;
 *      static $TUESDAY;
 *      static $WEDNESDAY;
 *      static $THURSDAY;
 *      static $FRIDAY;
 *      static $SATURDAY;
 *      static $SUNDAY;
 * }
 * DaysOfTheWeek::init();
 * 
 * example.php
 * require_once("DaysOfTheWeek.class.php");
 * $today = date('N');
 * if ($today == DaysOfTheWeek::$SUNDAY || $today == DaysOfTheWeek::$SATURDAY)
 *      echo "It's weekend!";
 * 
 * Flags.class.php
 * abstract class Flags extends Enum{
 *      static $FLAG_1;
 *      static $FLAG_2;
 *      static $FLAG_3;
 * }
 * Flags::init(Enum::$BINARY_FLAG);
 * 
 * example2.php
 * require_once("Flags.class.php");
 * $flags = Flags::$FLAG_1 | Flags::$FLAG_2;
 * if ($flags & Flags::$FLAG_1)
 *      echo "Flag_1 is set";
 * 
 * @author Tiddo Langerak
 */
abstract class Enum{

    static $BINARY_FLAG = 1;
    /**
     * This function must be called to initialize the enumeration!
     * 
     * @param bool $flags If the USE_BINARY flag is provided, the enum values will be binary flag values. Default: no flags set.
     */ 
    public static function init($flags = 0){
        //First, we want to get a list of all static properties of the enum class. We'll use the ReflectionClass for this.
        $enum = get_called_class();
        $ref = new ReflectionClass($enum);
        $items = $ref->getStaticProperties();
        //Now we can start assigning values to the items. 
        if ($flags & self::$BINARY_FLAG){
            //If we want binary flag values, our first value should be 1.
            $value = 1;
            //Now we can set the values for all items.
            foreach ($items as $key=>$item){
                if (!isset($item)){                 
                    //If no value is set manually, we should set it.
                    $enum::$$key = $value;
                    //And we need to calculate the new value
                    $value *= 2;
                } else {
                    //If there was already a value set, we will continue starting from that value, but only if that was a valid binary flag value.
                    //Otherwise, we will just skip this item.
                    if ($key != 0 && ($key & ($key - 1) == 0))
                        $value = 2 * $item;
                }
            }
        } else {
            //If we want to use regular indices, we'll start with index 0.
            $value = 0;
            //Now we can set the values for all items.
            foreach ($items as $key=>$item){
                if (!isset($item)){
                    //If no value is set manually, we should set it, and increment the value for the next item.
                    $enum::$$key = $value;
                    $value++;
                } else {
                    //If a value was already set, we'll continue from that value.
                    $value = $item+1;
                }
            }
        }
    }
}
Tiddo
fuente
3

Ahora puedes usar El clase SplEnum para construirla de forma nativa. Según la documentación oficial.

SplEnum ofrece la capacidad de emular y crear objetos de enumeración de forma nativa en PHP.

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

Tenga en cuenta que es una extensión que debe instalarse, pero que no está disponible de forma predeterminada. Que viene bajo Tipos especiales descritos en el sitio web php. El ejemplo anterior está tomado del sitio PHP.

Krishnadas PC
fuente
3

Finalmente, una respuesta de PHP 7.1+ con constantes que no se pueden anular.

/**
 * An interface that groups HTTP Accept: header Media Types in one place.
 */
interface MediaTypes
{
    /**
    * Now, if you have to use these same constants with another class, you can
    * without creating funky inheritance / is-a relationships.
    * Also, this gets around the single inheritance limitation.
    */

    public const HTML = 'text/html';
    public const JSON = 'application/json';
    public const XML = 'application/xml';
    public const TEXT = 'text/plain';
}

/**
 * An generic request class.
 */
abstract class Request
{
    // Why not put the constants here?
    // 1) The logical reuse issue.
    // 2) Single Inheritance. 
    // 3) Overriding is possible.

    // Why put class constants here?
    // 1) The constant value will not be necessary in other class families.
}

/**
 * An incoming / server-side HTTP request class.
 */
class HttpRequest extends Request implements MediaTypes
{
    // This class can implement groups of constants as necessary.
}

Si está utilizando espacios de nombres, la finalización del código debería funcionar.

Sin embargo, al hacer esto, pierde la capacidad de ocultar las constantes dentro de la familia de clases ( protected) o la clase sola ( private). Por definición, todo en un Interfacees public.

Manual PHP: Interfaces

Anthony Rutledge
fuente
Esto no es Java. Esto funciona en casos donde el patrón de polimorfismo / estrategia no es necesario para anular constantes en una clase principal.
Anthony Rutledge
2

Esta es mi opinión sobre la enumeración "dinámica" ... para poder llamarla con variables, ej. de un formulario.

mira la versión actualizada debajo de este bloque de código ...

$value = "concert";
$Enumvalue = EnumCategory::enum($value);
//$EnumValue = 1

class EnumCategory{
    const concert = 1;
    const festival = 2;
    const sport = 3;
    const nightlife = 4;
    const theatre = 5;
    const musical = 6;
    const cinema = 7;
    const charity = 8;
    const museum = 9;
    const other = 10;

    public function enum($string){
        return constant('EnumCategory::'.$string);
    }
}

ACTUALIZACIÓN: Mejor forma de hacerlo ...

class EnumCategory {

    static $concert = 1;
    static $festival = 2;
    static $sport = 3;
    static $nightlife = 4;
    static $theatre = 5;
    static $musical = 6;
    static $cinema = 7;
    static $charity = 8;
    static $museum = 9;
    static $other = 10;

}

Llamar con

EnumCategory::${$category};
Anders
fuente
55
El problema con este ser; EnumCategory::$sport = 9;. Bienvenido al museo del deporte. const Es la mejor manera de hacerlo.
Dan Lugg
2

La respuesta aceptada es el camino a seguir y en realidad es lo que estoy haciendo por simplicidad. Se ofrecen la mayoría de las ventajas de la enumeración (legible, rápida, etc.). Sin embargo, falta un concepto: tipo de seguridad. En la mayoría de los idiomas, las enumeraciones también se usan para restringir los valores permitidos. A continuación se muestra un ejemplo de cómo la seguridad de tipos también se puede obtener mediante el uso de constructores privados, métodos de creación de instancias estáticas y verificación de tipos:

class DaysOfWeek{
 const Sunday = 0;
 const Monday = 1;
 // etc.

 private $intVal;
 private function __construct($intVal){
   $this->intVal = $intVal;
 }

 //static instantiation methods
 public static function MONDAY(){
   return new self(self::Monday);
 }
 //etc.
}

//function using type checking
function printDayOfWeek(DaysOfWeek $d){ //compiler can now use type checking
  // to something with $d...
}

//calling the function is safe!
printDayOfWeek(DaysOfWeek::MONDAY());

Incluso podríamos ir más allá: el uso de constantes en la clase DaysOfWeek podría provocar un mal uso: por ejemplo, uno podría usarlo por error de esta manera:

printDayOfWeek(DaysOfWeek::Monday); //triggers a compiler error.

que está mal (llama a entero constante). Podemos evitar esto usando variables privadas estáticas en lugar de constantes:

class DaysOfWeeks{

  private static $monday = 1;
  //etc.

  private $intVal;
  //private constructor
  private function __construct($intVal){
    $this->intVal = $intVal;
  }

  //public instantiation methods
  public static function MONDAY(){
    return new self(self::$monday);
  }
  //etc.


  //convert an instance to its integer value
  public function intVal(){
    return $this->intVal;
  }

}

Por supuesto, no es posible acceder a constantes enteras (este era realmente el propósito). El método intVal permite convertir un objeto DaysOfWeek a su representación entera.

Tenga en cuenta que incluso podríamos ir más allá implementando un mecanismo de almacenamiento en caché en los métodos de creación de instancias para ahorrar memoria en el caso de que las enumeraciones se utilicen ampliamente ...

Espero que esto ayude

Vincent Pazeller
fuente
2

¡Algunas buenas soluciones aquí!

Aquí está mi versión.

  • Está fuertemente tipado
  • Funciona con autocompletado IDE
  • Las enumeraciones se definen mediante un código y una descripción, donde el código puede ser un número entero, un valor binario, una cadena corta o, básicamente, cualquier otra cosa que desee. El patrón podría extenderse fácilmente para admitir otras propiedades.
  • Admite comparaciones de valor (==) y referencia (===) y funciona en declaraciones de cambio.

Creo que la principal desventaja es que los miembros de enumeración deben declararse e instanciarse por separado, debido a las descripciones y la incapacidad de PHP para construir objetos en el tiempo de declaración de miembro estático. Supongo que una forma de evitar esto podría ser utilizar la reflexión con comentarios de documentos analizados en su lugar.

La enumeración abstracta se ve así:

<?php

abstract class AbstractEnum
{
    /** @var array cache of all enum instances by class name and integer value */
    private static $allEnumMembers = array();

    /** @var mixed */
    private $code;

    /** @var string */
    private $description;

    /**
     * Return an enum instance of the concrete type on which this static method is called, assuming an instance
     * exists for the passed in value.  Otherwise an exception is thrown.
     *
     * @param $code
     * @return AbstractEnum
     * @throws Exception
     */
    public static function getByCode($code)
    {
        $concreteMembers = &self::getConcreteMembers();

        if (array_key_exists($code, $concreteMembers)) {
            return $concreteMembers[$code];
        }

        throw new Exception("Value '$code' does not exist for enum '".get_called_class()."'");
    }

    public static function getAllMembers()
    {
        return self::getConcreteMembers();
    }

    /**
     * Create, cache and return an instance of the concrete enum type for the supplied primitive value.
     *
     * @param mixed $code code to uniquely identify this enum
     * @param string $description
     * @throws Exception
     * @return AbstractEnum
     */
    protected static function enum($code, $description)
    {
        $concreteMembers = &self::getConcreteMembers();

        if (array_key_exists($code, $concreteMembers)) {
            throw new Exception("Value '$code' has already been added to enum '".get_called_class()."'");
        }

        $concreteMembers[$code] = $concreteEnumInstance = new static($code, $description);

        return $concreteEnumInstance;
    }

    /**
     * @return AbstractEnum[]
     */
    private static function &getConcreteMembers() {
        $thisClassName = get_called_class();

        if (!array_key_exists($thisClassName, self::$allEnumMembers)) {
            $concreteMembers = array();
            self::$allEnumMembers[$thisClassName] = $concreteMembers;
        }

        return self::$allEnumMembers[$thisClassName];
    }

    private function __construct($code, $description)
    {
        $this->code = $code;
        $this->description = $description;
    }

    public function getCode()
    {
        return $this->code;
    }

    public function getDescription()
    {
        return $this->description;
    }
}

Aquí hay un ejemplo de enumeración concreta:

<?php

require('AbstractEnum.php');

class EMyEnum extends AbstractEnum
{
    /** @var EMyEnum */
    public static $MY_FIRST_VALUE;
    /** @var EMyEnum */
    public static $MY_SECOND_VALUE;
    /** @var EMyEnum */
    public static $MY_THIRD_VALUE;

    public static function _init()
    {
        self::$MY_FIRST_VALUE = self::enum(1, 'My first value');
        self::$MY_SECOND_VALUE = self::enum(2, 'My second value');
        self::$MY_THIRD_VALUE = self::enum(3, 'My third value');
    }
}

EMyEnum::_init();

Que se puede usar así:

<?php

require('EMyEnum.php');

echo EMyEnum::$MY_FIRST_VALUE->getCode().' : '.EMyEnum::$MY_FIRST_VALUE->getDescription().PHP_EOL.PHP_EOL;

var_dump(EMyEnum::getAllMembers());

echo PHP_EOL.EMyEnum::getByCode(2)->getDescription().PHP_EOL;

Y produce esta salida:

1: mi primer valor

array (3) {
[1] =>
object (EMyEnum) # 1 (2) {
["code": "AbstractEnum": private] =>
int (1)
["description": "AbstractEnum": private] =>
cadena (14) "Mi primer valor"
}
[2] =>
objeto (EMyEnum) # 2 (2) {
["código": "AbstractEnum": privado] =>
int (2)
["descripción": "AbstractEnum" : privado] =>
cadena (15) "Mi segundo valor"
}
[3] =>
objeto (EMyEnum) # 3 (2) {
["código": "AbstractEnum": privado] =>
int (3)
["descripción": "AbstractEnum": privado] =>
cadena (14) "Mi tercer valor"
}
}

Mi segundo valor

Dan King
fuente
2
class DayOfWeek {
    static $values = array(
        self::MONDAY,
        self::TUESDAY,
        // ...
    );

    const MONDAY  = 0;
    const TUESDAY = 1;
    // ...
}

$today = DayOfWeek::MONDAY;

// If you want to check if a value is valid
assert( in_array( $today, DayOfWeek::$values ) );

No uses la reflexión. Hace que sea extremadamente difícil razonar sobre su código y rastrear dónde se está usando algo, y tiende a romper las herramientas de análisis estático (por ejemplo, lo que está integrado en su IDE).

Jesse
fuente
2

Uno de los aspectos que faltan en algunas de las otras respuestas aquí es una forma de usar enumeraciones con sugerencias de tipo.

Si define su enumeración como un conjunto de constantes en una clase abstracta, por ejemplo

abstract class ShirtSize {
    public const SMALL = 1;
    public const MEDIUM = 2;
    public const LARGE = 3;
}

entonces no se puede escribir insinuar que en función de un parámetro - por un lado, porque no es instanciable, sino también por el tipo de ShirtSize::SMALLes int, no ShirtSize.

Es por eso que las enumeraciones nativas en PHP serían mucho mejores que cualquier cosa que se nos ocurra. Sin embargo, podemos aproximar una enumeración manteniendo una propiedad privada que represente el valor de la enumeración y luego restringiendo la inicialización de esta propiedad a nuestras constantes predefinidas. Para evitar que la enumeración se instancia de forma arbitraria (sin la sobrecarga de la verificación de tipo de una lista blanca), hacemos que el constructor sea privado.

class ShirtSize {
    private $size;
    private function __construct ($size) {
        $this->size = $size;
    }
    public function equals (ShirtSize $s) {
        return $this->size === $s->size;
    }
    public static function SMALL () { return new self(1); }
    public static function MEDIUM () { return new self(2); }
    public static function LARGE () { return new self(3); }
}

Entonces podemos usar ShirtSizeasí:

function sizeIsAvailable ($productId, ShirtSize $size) {
    // business magic
}
if(sizeIsAvailable($_GET["id"], ShirtSize::LARGE())) {
    echo "Available";
} else {
    echo "Out of stock.";
}
$s2 = ShirtSize::SMALL();
$s3 = ShirtSize::MEDIUM();
echo $s2->equals($s3) ? "SMALL == MEDIUM" : "SMALL != MEDIUM";

De esta manera, la mayor diferencia desde la perspectiva del usuario es que debe agregar un () a la constante.

Sin embargo, una desventaja es que ===(que compara la igualdad de objetos) devolverá falso cuando ==devuelva verdadero. Por esa razón, es mejor proporcionar un equalsmétodo, para que los usuarios no tengan que acordarse de usar ==y no=== comparar dos valores de enumeración.

EDITAR: Algunas de las respuestas existentes son muy similares, particularmente: https://stackoverflow.com/a/25526473/2407870 .

Chris Middleton
fuente
2

Al pisar la respuesta de @Brian Cline, pensé que podría dar mis 5 centavos

<?php 
/**
 * A class that simulates Enums behaviour
 * <code>
 * class Season extends Enum{
 *    const Spring  = 0;
 *    const Summer = 1;
 *    const Autumn = 2;
 *    const Winter = 3;
 * }
 * 
 * $currentSeason = new Season(Season::Spring);
 * $nextYearSeason = new Season(Season::Spring);
 * $winter = new Season(Season::Winter);
 * $whatever = new Season(-1);               // Throws InvalidArgumentException
 * echo $currentSeason.is(Season::Spring);   // True
 * echo $currentSeason.getName();            // 'Spring'
 * echo $currentSeason.is($nextYearSeason);  // True
 * echo $currentSeason.is(Season::Winter);   // False
 * echo $currentSeason.is(Season::Spring);   // True
 * echo $currentSeason.is($winter);          // False
 * </code>
 * 
 * Class Enum
 * 
 * PHP Version 5.5
 */
abstract class Enum
{
    /**
     * Will contain all the constants of every enum that gets created to 
     * avoid expensive ReflectionClass usage
     * @var array
     */
    private static $_constCacheArray = [];
    /**
     * The value that separates this instance from the rest of the same class
     * @var mixed
     */
    private $_value;
    /**
     * The label of the Enum instance. Will take the string name of the 
     * constant provided, used for logging and human readable messages
     * @var string
     */
    private $_name;
    /**
     * Creates an enum instance, while makes sure that the value given to the 
     * enum is a valid one
     * 
     * @param mixed $value The value of the current
     * 
     * @throws \InvalidArgumentException
     */
    public final function __construct($value)
    {
        $constants = self::_getConstants();
        if (count($constants) !== count(array_unique($constants))) {
            throw new \InvalidArgumentException('Enums cannot contain duplicate constant values');
        }
        if ($name = array_search($value, $constants)) {
            $this->_value = $value;
            $this->_name = $name;
        } else {
            throw new \InvalidArgumentException('Invalid enum value provided');
        }
    }
    /**
     * Returns the constant name of the current enum instance
     * 
     * @return string
     */
    public function getName()
    {
        return $this->_name;
    }
    /**
     * Returns the value of the current enum instance
     * 
     * @return mixed
     */
    public function getValue()
    {
        return $this->_value;
    }
    /**
     * Checks whether this enum instance matches with the provided one.
     * This function should be used to compare Enums at all times instead
     * of an identity comparison 
     * <code>
     * // Assuming EnumObject and EnumObject2 both extend the Enum class
     * // and constants with such values are defined
     * $var  = new EnumObject('test'); 
     * $var2 = new EnumObject('test');
     * $var3 = new EnumObject2('test');
     * $var4 = new EnumObject2('test2');
     * echo $var->is($var2);  // true
     * echo $var->is('test'); // true
     * echo $var->is($var3);  // false
     * echo $var3->is($var4); // false
     * </code>
     * 
     * @param mixed|Enum $enum The value we are comparing this enum object against
     *                         If the value is instance of the Enum class makes
     *                         sure they are instances of the same class as well, 
     *                         otherwise just ensures they have the same value
     * 
     * @return bool
     */
    public final function is($enum)
    {
        // If we are comparing enums, just make
        // sure they have the same toString value
        if (is_subclass_of($enum, __CLASS__)) {
            return get_class($this) === get_class($enum) 
                    && $this->getValue() === $enum->getValue();
        } else {
            // Otherwise assume $enum is the value we are comparing against
            // and do an exact comparison
            return $this->getValue() === $enum;   
        }
    }

    /**
     * Returns the constants that are set for the current Enum instance
     * 
     * @return array
     */
    private static function _getConstants()
    {
        if (self::$_constCacheArray == null) {
            self::$_constCacheArray = [];
        }
        $calledClass = get_called_class();
        if (!array_key_exists($calledClass, self::$_constCacheArray)) {
            $reflect = new \ReflectionClass($calledClass);
            self::$_constCacheArray[$calledClass] = $reflect->getConstants();
        }
        return self::$_constCacheArray[$calledClass];
    }
}
Loupax
fuente
Por alguna razón no puedo llamar a esto funciones. Me dice que tales funciones no se declaran. ¿Qué estoy haciendo mal? [clase básica Enum ubicada en otro archivo y estoy usando include('enums.php');]. Por alguna razón, no ve las funciones declaradas en Enum para las clases infantiles ...
Andrew
Además ... ¿cómo configurarlo desde una cadena? algo así$currentSeason.set("Spring");
Andrew
1

Mi intento de crear una enumeración con PHP ... es extremadamente limitado ya que no admite objetos como los valores de enumeración, pero sigue siendo algo útil ...

class ProtocolsEnum {

    const HTTP = '1';
    const HTTPS = '2';
    const FTP = '3';

    /**
     * Retrieve an enum value
     * @param string $name
     * @return string
     */
    public static function getValueByName($name) {
        return constant('self::'. $name);
    } 

    /**
     * Retrieve an enum key name
     * @param string $code
     * @return string
     */
    public static function getNameByValue($code) {
        foreach(get_class_constants() as $key => $val) {
            if($val == $code) {
                return $key;
            }
        }
    }

    /**
     * Retrieve associate array of all constants (used for creating droplist options)
     * @return multitype:
     */
    public static function toArray() {      
        return array_flip(self::get_class_constants());
    }

    private static function get_class_constants()
    {
        $reflect = new ReflectionClass(__CLASS__);
        return $reflect->getConstants();
    }
}
KDog
fuente
Está limitado en muchas direcciones y las respuestas existentes ofrecen mucho más. Yo diría que esto realmente no agrega nada útil.
Hakre
1

Ayer escribí esta clase en mi blog . Creo que puede ser fácil de usar en scripts php:

final class EnumException extends Exception{}

abstract class Enum
{
    /**
     * @var array ReflectionClass
     */
    protected static $reflectorInstances = array();
    /**
     * Массив конфигурированного объекта-константы enum
     * @var array
     */
    protected static $enumInstances = array();
    /**
     * Массив соответствий значение->ключ используется для проверки - 
     * если ли константа с таким значением
     * @var array
     */
    protected static $foundNameValueLink = array();

    protected $constName;
    protected $constValue;

    /**
     * Реализует паттерн "Одиночка"
     * Возвращает объект константы, но но как объект его использовать не стоит, 
     * т.к. для него реализован "волшебный метод" __toString()
     * Это должно использоваться только для типизачии его как параметра
     * @paradm Node
     */
    final public static function get($value)
    {
        // Это остается здесь для увеличения производительности (по замерам ~10%)
        $name = self::getName($value);
        if ($name === false)
            throw new EnumException("Неизвестая константа");
        $className = get_called_class();    
        if (!isset(self::$enumInstances[$className][$name]))
        {
            $value = constant($className.'::'.$name);
            self::$enumInstances[$className][$name] = new $className($name, $value);
        }

        return self::$enumInstances[$className][$name];
    }

    /**
     * Возвращает массив констант пар ключ-значение всего перечисления
     * @return array 
     */
    final public static function toArray()
    {
        $classConstantsArray = self::getReflectorInstance()->getConstants();
        foreach ($classConstantsArray as $k => $v)
            $classConstantsArray[$k] = (string)$v;
        return $classConstantsArray;
    }

    /**
     * Для последующего использования в toArray для получения массива констант ключ->значение 
     * @return ReflectionClass
     */
    final private static function getReflectorInstance()
    {
        $className = get_called_class();
        if (!isset(self::$reflectorInstances[$className]))
        {
            self::$reflectorInstances[$className] = new ReflectionClass($className);
        }
        return self::$reflectorInstances[$className];
    }

    /**
     * Получает имя константы по её значению
     * @param string $value
     */
    final public static function getName($value)
    {
        $className = (string)get_called_class();

        $value = (string)$value;
        if (!isset(self::$foundNameValueLink[$className][$value]))
        {
            $constantName = array_search($value, self::toArray(), true);
            self::$foundNameValueLink[$className][$value] = $constantName;
        }
        return self::$foundNameValueLink[$className][$value];
    }

    /**
     * Используется ли такое имя константы в перечислении
     * @param string $name
     */
    final public static function isExistName($name)
    {
        $constArray = self::toArray();
        return isset($constArray[$name]);
    }

    /**
     * Используется ли такое значение константы в перечислении
     * @param string $value
     */
    final public static function isExistValue($value)
    {
        return self::getName($value) === false ? false : true;
    }   


    final private function __clone(){}

    final private function __construct($name, $value)
    {
        $this->constName = $name;
        $this->constValue = $value;
    }

    final public function __toString()
    {
        return (string)$this->constValue;
    }
}

Uso:

class enumWorkType extends Enum
{
        const FULL = 0;
        const SHORT = 1;
}
Arturgspb
fuente
2
Pero es buena clase y el nombre de las funciones es nativo. Y también translate.google.ru tal vez ayuda.
Arturgspb
2
Usa chrome guys y traduce, si eres programador, ¡lees código!
Markus
8
En general, siempre es mejor incluir el código en la respuesta, en lugar de vincularlo a un recurso externo que puede o no estar allí en 'n' meses / años, etc.
John Parker
Mi clase es muy grande y creo que leer esta publicación será inconveniente.
Arturgspb
Creo que hay dos cosas malas aquí: está en ruso (cada programador debe saber inglés y usarlo, incluso en los comentarios) y no está incluido aquí. Consulte la ayuda sobre cómo incluir código enorme.
gaRex