Por que === é mais rápido que == no PHP?

Por que é ===mais rápido que ==no PHP?

Como o operador de igualdade ==coage ou converte, o tipo de dados temporariamente para ver se é igual ao outro operando, enquanto ===(o operador de identidade) não precisa fazer nenhuma conversão e, portanto, menos trabalho é feito, o que o torna mais rápido.

===não executa a conversão de tipo, então 0 == '0'avalia para true, mas 0 === '0'- para false.

Primeiro, === verifica se os dois argumentos são do mesmo tipo - portanto, o número 1 e a string '1' falham na verificação de tipo antes que quaisquer comparações sejam realmente realizadas. Por outro lado, == não verifica o tipo primeiro e segue em frente e converte os dois argumentos no mesmo tipo e depois faz a comparação.

Portanto, === é mais rápido na verificação de uma condição de falha

Há duas coisas a considerar:

1. Se tipos de operando é diferente ==e ===produzir resultados diferentes . Nesse caso, a velocidade dos operadores não importa; o que importa é qual produz o resultado desejado.

2. Se os tipos de operando forem iguais, você poderá usar um ==ou ===ambos, pois ambos produzirão os mesmos resultados . Nesse caso, a velocidade dos dois operadores é quase idêntica. Isso ocorre porque nenhuma conversão de tipo é realizada por nenhum dos operadores.

Eu comparei a velocidade de:

• $a == $b vs $a === $b
• onde $ae $bforam números inteiros aleatórios [1, 100]
• as duas variáveis ​​foram geradas e comparadas um milhão de vezes
• os testes foram executados 10 vezes

E aqui estão os resultados:

 $a == $b $a === $b
--------- ---------
 0.765770  0.762020
 0.753041  0.825965
 0.770631  0.783696
 0.787824  0.781129
 0.757506  0.796142
 0.773537  0.796734
 0.768171  0.767894
 0.747850  0.777244
 0.836462  0.826406
 0.759361  0.773971
--------- ---------
 0.772015  0.789120

Você pode ver que a velocidade é quase idêntica.

Eu realmente não sei se é significativamente mais rápido, mas === na maioria dos idiomas é uma comparação direta de tipos, enquanto == tentará fazer coerção de tipo, se necessário / possível para obter uma correspondência.

O == incorre em uma sobrecarga maior de conversão de tipo antes da comparação. === primeiro verifica o tipo e depois continua sem precisar fazer nenhuma conversão de tipo.

Porque === não precisa coagir os operandos a serem do mesmo tipo antes de compará-los.

Duvido que a diferença de velocidade seja muito grande. Em circunstâncias normais, você deve usar o operador que fizer mais sentido.

Em conclusão, === é mais rápido, porque não converte o tipo de dados para ver se duas variáveis ​​têm o mesmo valor, mas quando você precisar ver se duas variáveis ​​têm o mesmo valor, você usará == se não for mais matemático, que tipo são variáveis ou === se for importante também o tipo de variáveis.

Mais rápido não deve ser medido apenas no tempo de execução direta (neste caso, os testes de desempenho direto são quase insignificantes). Dito isso, eu precisaria ver um teste envolvendo iteração ou recursão para realmente ver se há uma diferença cumulativa significativa (quando usada em um contexto realista). O tempo de teste e depuração que você economizará ao lidar com casos extremos deve ser significativo para você, também

No php (código c), o valor é uma "classe" como:

class value
{
    $int_;
    $float_;
    $string_;
    $array_;
    $object_;
}

Quando você está comparando $a == $be $aé do inttipo, haverá algo como:

if ($a->int_ == $b->int_ || $a->int_ == (int) $b->float_ || $a->int_ == (int) $b->string_ || ...)

mas string '1'não será convertido para código ascii 49, será 1.

Quando você está comparando $a === $be $aé do inttipo, haverá algo como:

if ($a->int_ == $b->int_)

Se os resultados do teste estiverem corretos, será um problema do compilador,

O processador fará o que for solicitado para fazer em um ciclo de clock

Se tiver menos a fazer, será mais rápido fazer

Adição:

Ah, na verdade, se o compilador já criou um monte de código de máquina a ser processado, se já adicionou milhões de itens para lidar com que tipo de dados precisa ser comparado, a remoção de um "menor" SE não mudará muito a velocidade em absoluto.

Se alguém ainda lê isso, então eu sou interessante em mais discussões.

Phil