¿Por qué es = = = más rápido que = = en PHP?

=== no realiza encasillamiento, por lo que 0 == '0' evalúa a true, pero 0 === '0' - a false.

Primero, === comprueba si los dos argumentos son el mismo tipo - por lo que el número 1 y la cadena '1' falla en la comprobación de tipo antes de que se lleven a cabo las comparaciones. Por otro lado, = = no comprueba el tipo primero y sigue adelante y convierte ambos argumentos al mismo tipo y luego hace la comparación.

Por lo tanto, = = = es más rápido en la comprobación de una condición de falla

Hay dos cosas a considerar:

1. Si los tipos de operando son diferentes entonces == y === producen resultados diferentes. En ese caso, la velocidad de los operadores no importa; lo que importa es cuál produce el resultado deseado.

2. Si los tipos de operando son iguales, entonces puede usar == o === ya que ambos producirán los mismos resultados. En ese caso, la velocidad de ambos operadores es casi idéntica. Esto se debe a que ningún tipo la conversión es realizada por cualquiera de los operadores.

Comparé la velocidad de:

• $a == $b vs $a === $b
• donde $a y $b eran enteros aleatorios [1, 100]
• las dos variables se generaron y compararon un millón de veces
• las pruebas se realizaron 10 veces

Y aquí están los 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

Puedes ver que la velocidad es casi idéntica.

Realmente no sé si es significativamente más rápido, pero === en la mayoría de los idiomas es una comparación de tipos directa, mientras que == intentará hacer coerción de tipos si es necesario/posible para obtener una coincidencia.

El == incurre en una sobrecarga mayor de conversión de tipos antes de la comparación. = = = primero comprueba el tipo, luego procede sin tener que hacer ninguna conversión de tipo.

Porque === no necesita coaccionar los operandos para que sean del mismo tipo antes de compararlos.

Dudo que la diferencia de velocidad sea muy grande. En circunstancias normales, debe usar el operador que tenga más sentido.

En conclusión === es más rápido porque no convierte el tipo de datos para ver si dos variables tienen el mismo valor, pero cuando necesita ver si dos variables tienen el mismo valor utilizará == if doesen't mather what type are variables, or === if is important also the type of variables.

Faster no solo debe medirse en tiempo de ejecución directa (las pruebas de rendimiento directo son casi insignificantes en este caso). Dicho esto, necesitaría ver una prueba que involucre iteración, o recursión, para ver realmente si hay una diferencia significativa y acumulativa (cuando se usa en un contexto realista). El tiempo de prueba y depuración que ahorrará al tratar con casos extremos debería ser significativo para usted, también

Si los resultados de la prueba son correctos, entonces debe ser un problema del compilador,

El procesador hará lo que se le diga que haga en un ciclo de reloj

Si tiene menos que hacer, entonces será más rápido hacerlo

Suma:

Ah bien en realidad si el compilador ya ha creado cargas de código de máquina para ser procesado, entonces si ya ha agregado zillones de cosas para hacer frente a qué tipo de datos necesita comparar, entonces la eliminación de un "menor" SI no cambiará las velocidades mucho en todo.

Si alguien todavía lee esto, entonces estoy interesante en más discusión.

Phil