Por que === mais rápido do que == em PHP?

Question

Por que é === mais rápido do que == em PHP?

Answer 1

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

Answer 2

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

Answer 3

Primeiro, === verifica se os dois argumentos são os mesmos modelo - Portanto, o número 1 e a string '1' falham na verificação do tipo antes que qualquer comparação seja realmente realizada. Por outro lado, == não verifica o tipo primeiro e segue em frente e converte os dois argumentos para o mesmo tipo e depois a comparação.

Portanto, === é mais rápido em verificar uma condição de falha

Answer 4

Há duas coisas a considerar:

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

2. Se o operando tipos são mesmo, em seguida, você pode usar um == ou === como ambos irão produzir mesmo resultados.Nesse caso, a velocidade de ambos os operadores, é quase idêntico.Isto porque nenhum tipo de conversão é executado por operadores.

Eu comparada a velocidade de:

• $a == $b vs $a === $b
• onde $a e $b foram aleatórios inteiros [1, 100]
• as duas variáveis foram gerados e comparados 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êntico.

Answer 5

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

Answer 6

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

Answer 7

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

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

Answer 8

Em conclusão === é mais rápido porque não converte o tipo de dados para verificar se duas variáveis tem o mesmo valor, mas quando você precisar verificar se duas variáveis tem o mesmo valor que você usará == se doesen't mather que tipo são as variáveis, ou === se é importante também o tipo de variáveis.

Answer 9

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

Answer 10

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

O processador fará o que for dito para fazer em um ciclo de relógio

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

Adição:

Ah, bem, na verdade, se o compilador já criou cargas de código de máquina a serem processadas, se já adicionou zilhões de coisas para lidar com que tipo de dados precisa comparar, então a remoção de um "menor" se não mudar de velocidade muito de forma alguma.

Se alguém ainda lê isso, estou interessante em mais discussões.

Phil