PHP Constantes: Vantagens / Desvantagens

Question

Ultimamente tenho tido o hábito de atribuir valores inteiros a constantes e simplesmente usando o nome constante como um meio de identificar o seu propósito. No entanto, em alguns casos, isso resultou na necessidade de escrever uma função como typeToString ($ const), quando é necessária uma representação string. Obviamente, isso é ineficiente e unneccesary, mas é apenas um problema de vez em quando.

Então, minha pergunta é, existem outras compensações que eu deveria considerar? Que caso é considerado mais limpo / mais compatível com os padrões? Além disso, é o insignificante diferença de desempenho para a maioria dos casos?

Caso 1: (mais rápido quando uma versão cadeia não é necessário)

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: (mais rápido / mais fácil quando uma versão string é necessária)

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

A diferença de desempenho será insignificante a menos que você está armazenando um monte deles. Eu ia escrever o método toString() de forma mais concisa:

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

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

return $strings[$type];

Além disso, você poderia fazer a matriz $strings um static.

Answer 2

Eu vou ser honesto, eu não sei se há uma performance "hit" de qualquer tipo quando você definir suas constantes nativamente como cordas - mas se houver um em tudo que eu estou disposto a apostar que ele é tão pequeno seria difícil de medir.

Pessoalmente, se o valor da constante é significativo como um literal, em seguida, basta atribuir-lhe esse valor. Se o valor da constante só tem sentido como um seletor de opção (ou algum outro indicação do valor), então use inteiros ou o que você escolher apropriado.

Answer 3

Eu acho que as constantes string são a melhor escolha neste caso. Código parece melhor.

É claro que se você precisa último pedaço de desempenho, o uso inteiro constantes. Mas só depois de verificar com um perfil que comparações de cadeias são o gargalo. De qualquer forma, na maioria das aplicações, há muitas coisas mais caras, como acesso à base de dados etc.

Answer 4

Em vez de usar números inteiros const Eu geralmente apenas ir com cordas se eu precisar imprimi-las. Então eu faria algo como $foo = new Foo('guest');. Eu ainda pode validar a entrada no construtor e posso marcá-lo sempre que precisar.

Answer 5

No exemplo que você escreve você pode soltar todos os métodos e fazer a classe estática e você teria criado a sua auto um enumerador. Como esta:

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

Uma outra maneira útil para usar constantes é usá-los como configuração da aplicação. Eles são muito mais rápido desempenho sábio, em seguida, analisar um arquivo xml para configuração.