151

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

+35

Es más rápido, pero ¿es * significativamente * más rápido? – Piskvor

+18

Por favor, no lea sobre lo que es más rápido en php. Lea sobre cómo obtener datos interesantes en una consulta de SQL simple sin abusar de JOIN. –

+15

A quien podría interesarle el mismo tema '=== vs ==', pero en JAVASCRIPT, puede leer aquí: http://stackoverflow.com/questions/359494/javascript-vs-does-it-matter- que-igual-operador-yo-uso –

Respuesta

173

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

+0

Creo que su opinión es contraria a lo que dice el Manual de PHP. Dicen que $ a == $ b es VERDADERO si $ a es igual a $ b, donde $ a === $ b es VERDADERO si $ a es igual a $ b, y son del mismo tipo. – Bakhtiyor

+81

¿Cómo es lo contrario, entonces? –

+2

Creo que es en realidad que los 2 operandos apuntan a la misma área de memoria para tipos complejos, pero la respuesta de Meder abarca – Basic

7

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

+9

Javascript tiene el operador ===. –

+0

Estoy seguro de que puede hacer === en el ceceo y el esquema comunes. – Pablo

+0

Javascript - no está en las 3 definiciones de idioma que revisé;) Y Lisp y Scheme son muchas cosas, pero apenas comunes;) – TomTom

22

Primero, === comprueba si los dos argumentos son los mismos tipo - por lo que el número 1 y la cadena '1' fallan en la verificación de tipo antes de que se realicen realmente las comparaciones. Por otro lado, == no comprueba primero el tipo y continúa y convierte ambos argumentos en el mismo tipo y luego realiza la comparación.

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

+6

Supongo que '==' también verifica primero el tipo para ver si es necesario realizar alguna conversión de tipo.El hecho de que '===' no haga ninguna conversión en el siguiente paso es lo que lo hace más rápido. – deceze

49

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

4

El == incurre en una sobrecarga mayor 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.

2

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, usará == si no importa qué tipo son variables, o === si también es importante el tipo de variables.

12

hay dos cosas a tener en cuenta:

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

I comparó la velocidad de:

  • $a == $b vs $a === $b
  • donde $a y $b fueron enteros aleatorios [1, 100]
  • las dos variables fueron generados y compararon un millón de veces
  • las pruebas se ejecutaron 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 

se puede ver que la velocidad es casi idéntica.

+9

me pregunto qué pasaría si haces miles de millones de iteraciones en una máquina que no está haciendo otra cosa y solo sacas el promedio. parece que hay mucho ruido aquí. ;) –

+1

Llegué a la misma conclusión: no se podría cuestionar ninguna diferencia si se sabe que los operandos son del mismo tipo. Otros escenarios no hacen sentido. Casi todas las otras respuestas son simplemente incorrectas. –

-2

Si los resultados de las pruebas son correctas, entonces debe ser un tema compilador,

El procesador hará lo que se le dice que hacer en un ciclo de reloj

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

adición:

Ah, bueno en realidad, si el compilador ya ha creado un montón de código de máquina para ser procesados, a continuación, si ya ha añadido infinidad de cosas para hacer frente a qué tipo de necesidades de datos comparando, entonces el remo El valor de un IF "menor" no cambiará las velocidades en absoluto.

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

Phil

Cuestiones relacionadas