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

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

Debido a que el operador de igualdad ==coacciona o convierte, el tipo de datos temporalmente para ver si es igual al otro operando, mientras que ===(el operador de identidad) no necesita hacer ninguna conversión y, por lo tanto, se realiza menos trabajo, lo que lo hace más rápido.

===no realiza la conversión de texto, por lo que 0 == '0'evalúa a true, pero 0 === '0'- a false.

Primero, === verifica si los dos argumentos son del mismo tipo , por lo que el número 1 y la cadena '1' fallan en la verificación de tipo antes de que se realicen 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 al verificar una condición de falla

Hay dos cosas a considerar:

1. Si los tipos de operandos son diferentes, ==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 operandos son los mismos, puede usar uno ==o ===ambos producirán los mismos resultados . En ese caso, la velocidad de ambos operadores es casi idéntica. Esto se debe a que ninguno de los operadores realiza conversión de tipo.

Comparé la velocidad de:

• $a == $b vs $a === $b
• donde $ay $beran enteros aleatorios [1, 100]
• las dos variables fueron generadas y comparadas 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 tipo directa, mientras que == intentará hacer una coerción de tipo si es necesario / posible para obtener una coincidencia.

El == incurre en una mayor sobrecarga de conversión de tipo antes de la comparación. === primero verifica el tipo, luego continúa sin tener que hacer ninguna conversión de tipo.

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

Sin embargo, 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 necesite ver si dos variables tienen el mismo valor, usará == si no importa qué tipo de variables son , o === si es importante también el tipo de variables.

Más rápido no solo debe medirse en tiempo de ejecución directo (las pruebas de rendimiento directo son casi insignificantes en este caso). Dicho esto, necesitaría ver una prueba que implique iteración o recursividad, 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 límite también debe ser significativo para usted

En php (código c) el valor es una "clase" como:

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

Cuando su están comparando $a == $by $aes intel tipo, habrá algo así como:

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

pero string '1'no se lanzará al código ASCII 49, lo será 1.

Cuando esté comparando $a === $by $aes inttipo, habrá algo como:

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

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

El procesador hará lo que se le indique en un ciclo de reloj.

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

Adición:

Ah, bueno, en realidad, si el compilador ya ha creado un montón de código de máquina para procesar, si ya ha agregado millones de cosas para hacer frente a qué tipo de datos necesita comparar, entonces la eliminación de un IF "menor" no cambiará mucho las velocidades en absoluto.

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

Phil