Constantes de PHP: Ventajas / Desventajas

Question

Últimamente he tenido la costumbre de asignar valores enteros a constantes y simplemente usar el nombre de la constante como medio para identificar su propósito. Sin embargo, en algunos casos esto ha generado la necesidad de escribir una función como typeToString ($ const) cuando se necesita una representación de cadena. Obviamente, esto es ineficiente e innecesario, pero solo es un problema de vez en cuando.

Entonces, mi pregunta es, ¿hay alguna otra compensación que deba considerar? ¿Qué caso se considera más limpio / más compatible con los estándares? Además, ¿es la diferencia de rendimiento despreciable en la mayoría de los casos?

Caso 1: (¿más rápido cuando no se necesita una versión de cadena?)

class Foo {
    const USER_TYPE_ADMIN = 0;
    const USER_TYPE_USER = 1;
    const USER_TYPE_GUEST = 2;

    public $userType = self::USER_TYPE_ADMIN;

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

    public function typeToString() {
        switch($this->userType) {
            case self::USER_TYPE_ADMIN:
                return 'admin';
                break;

            case self::USER_TYPE_USER:
                return 'user';
                break;

            case self::USER_TYPE_GUEST:
                return 'guest';
                break;

            default:
                return 'unknown';
                break;
        }
    }
}

$foo = new Foo(Foo::USER_TYPE_GUEST);
echo $foo->typeToString();
// Displays "guest"

Caso 2: (más rápido / más fácil cuando se necesita una versión de cadena)

class Foo {
    const USER_TYPE_ADMIN = 'admin';
    const USER_TYPE_USER = 'user';
    const USER_TYPE_GUEST = 'guest';

    public $userType = self::USER_TYPE_ADMIN;

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

$foo = new Foo(Foo::USER_TYPE_GUEST);
echo $foo->userType();
// Displays "guest"

Answer 1

La diferencia de rendimiento será despreciable a menos que esté almacenando muchos de ellos. Escribiría el método toString () de manera más concisa:

$strings = array
(
    self::USER_TYPE_ADMIN => 'admin',
    self::USER_TYPE_USER => 'user',
);

if (!isset($strings[$type]))
    return 'unknown';

return $strings[$type];

También, puede hacer que el código $ strings sea static .

Answer 2

Seré honesto, no sé si hay una actuación '' hit '' de cualquier tipo cuando define sus constantes de forma nativa como cadenas, pero si hay una, estoy dispuesto a apostar que es tan pequeña que sería difícil de medir.

Personalmente, si el valor de la constante es significativo como literal, entonces simplemente asígnele ese valor. Si el valor de la constante es significativo solo como un selector de opciones (o alguna otra indicación de valor), utilice enteros o lo que elija apropiado.

Answer 3

Creo que las constantes de cadena son la mejor opción en este caso. El código se ve mejor.

Por supuesto, si necesita el último bit de rendimiento, use constantes de enteros. Pero solo después de verificar con un generador de perfiles que las comparaciones de cadenas son el cuello de botella. De todos modos, en la mayoría de las aplicaciones hay muchas cosas más caras, como el acceso a la base de datos, etc.

Answer 4

En lugar de usar enteros constantes, generalmente solo uso cadenas si necesito imprimirlas. Entonces haría algo como $ foo = new Foo ('invitado'); . Todavía puedo validar la entrada en el constructor y puedo marcarla cuando lo necesite.

Answer 5

En el ejemplo que escribe, podría eliminar todos los métodos y hacer que la clase sea estática y se habría creado un Enumerador. Así:

class Enumeration{
  public static const One=1;
  public static const Two=2;
  public static const Three=3;
}

Otra forma útil de usar constantes es usarlas como configuración de la aplicación. Son mucho más rápidos en cuanto al rendimiento que el análisis de un archivo xml para la configuración.