diferencia - JavaScript-=== vs== rendimiento de los operadores

operadores de comparacion javascript

Question

Hace unas semanas, he leído este hilo ¿Es <más rápido que <=? sobre los operadores de comparación en C Se dijo que no hay diferencia en el rendimiento entre < y <= ya que se interpretan como comandos de máquina iguales / similares.

Al mismo tiempo, en las "mejores prácticas" de nuestra compañía, se dijo que siempre deberíamos usar "===" para comparar cosas en lugar de "==". Entonces, comencé a preguntarme si esto siempre es apropiado, ya que estoy acostumbrado a usar "==" y "typeof ... ==" y no quiero cambiar mi forma de escribir: -]

Tenga en cuenta que esto está en el contexto de JavaScript.

Entonces, tengo un poco de investigación y aquí ¿Qué operador es igual (== vs ===) se debe usar en las comparaciones de JavaScript? se dice que:

Esto se debe a que el operador de igualdad == no escribe coerción ... lo que significa que el intérprete intenta de manera implícita convertir los valores y luego hace la comparación.

Por otro lado, el operador de identidad === no realiza coacción de tipo, por lo que no convierte los valores de los valores al comparar

Y comencé a preguntarme si esto significa que cuando use el operador "===" obtendré un buen rendimiento ya que no se gastarán recursos en convertir los operandos. Y después de que todo el código se convierta en comandos de máquina, ¿esto significa que así como no hay diferencia en C cuando usa < y <= , esto es lo mismo en JavaScript y otros idiomas?

Answer 1

En primer lugar, el rendimiento simplemente no es una preocupación. Para cualquier script real, cualquier ganancia de rendimiento de usar un operador sobre el otro será infinitamente menor en comparación con otros cuellos de botella en el código (normalmente, la manipulación de DOM sería el objetivo número uno).

En segundo lugar, en muchos casos, == y === realizarán exactamente los mismos pasos . Cuando los tipos de los dos operandos son los mismos (dos cadenas o dos números, por ejemplo), la especificación ECMAScript tiene exactamente los mismos pasos para los dos operadores. Por lo tanto, si observa una diferencia de rendimiento entre los dos operadores para operandos del mismo tipo en un navegador u otro entorno, no hay garantía o incluso posibilidad de que vea una diferencia similar en otro navegador.

En el caso de typeof , como se mencionó en su pregunta, se garantiza que los dos operandos son del mismo tipo (cadena) y ambos operadores harán exactamente lo mismo, por lo que las únicas razones para favorecer a un operador sobre el otro son estilísticas .

La comunidad JS en su conjunto se ha vuelto bastante dura en esto: el consenso parece ser "nunca use == y != menos que necesite una coerción de tipo", que es demasiado dogmática para mi gusto.

Answer 2

Es un lenguaje de scripting. El rendimiento de estos operadores no debería importar tanto que debería preocuparse por ello, porque hay muchas otras cosas que consumen mucha más energía, como el hecho de que se ejecuta en una máquina virtual, está mal escrito, funciona con un HTML DOM dentro de un navegador ...

Además, ambos operadores hacen cosas muy diferentes, por lo que uno no puede ser intercambiable con el otro en ningún caso.

Dicho esto, creo (pero no he probado) que === es más rápido. La razón es que solo necesita comparar el tipo y, si coincide, comparar los datos sin procesar. El operador == intentará convertir un tipo a otro si no coinciden. Esta será una operación más cara en la mayoría de los casos.

Y eso es afortunado, porque en la mayoría de los casos === es la mejor opción. :)

Pero de todos modos, puedes probarlo fácilmente (asegúrate de probar varios casos, tanto con el mismo tipo como con un par de tipos diferentes), pero si no sabes cómo probarlo, dejaría de preocuparme por ello. La diferencia, si la hay, no te va a matar.

Answer 3

La diferencia de rendimiento es insignificante, lo que significa que no debe desperdiciar sus preciosos ciclos cerebrales pensando en ello. Si realmente quieres saberlo, deberías probar.

Use === menos que tenga una buena razón para no hacerlo (probablemente no la tenga).

Answer 4

No importa qué rendimiento obtenga, === es claramente la mejor opción en este caso. Cualquier otra cosa, como un mejor rendimiento, es solo la guinda del pastel. Además, la diferencia en ambos sentidos es mínima.

Answer 5

Siento que una respuesta con evidencia fácilmente verificable sería la mejor.

Estas operaciones son tan pequeñas que es difícil realizar pruebas de rendimiento.

• == 1648 verdad
• === 1629 verdad
• prueba de control 1575 verdadero

Si restas la prueba de control, parece que hay una diferencia de ~ 30% en sus velocidades en mi navegador. Si haces esto varias veces, puedes obtener respuestas diferentes, pero === por lo general sale más rápido, lo que creo que es solo una prueba de cuán insignificante es la diferencia.

Creo que esto demuestra bastante bien lo que otros decían, que la diferencia de rendimiento es una pérdida de tiempo para pensar, pero también muestra que === en realidad es más rápido. Esperemos que esta respuesta pueda ahorrar tiempo a otras personas, aquellos que simplemente deben ver pruebas.

var testString = "42";
var testNumber = 42;
var testObject = {};


var start = Date.now();
var result = null;
for(var i = 0; i < 100000000; i++){
    result = testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject && 
    testString == testString && testNumber == testNumber && testObject == testObject
}

console.log("==", Date.now() - start, result);

var start = Date.now();
var result = null;
for(var i = 0; i < 100000000; i++){
    result = testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject && 
    testString === testString && testNumber === testNumber && testObject === testObject
}
console.log("===", Date.now() - start, result);
var start = Date.now();
for(var i = 0; i < 100000000; i++){
    result =  true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true && 
    true && true && true
}
console.log("control test", Date.now() - start, result);

Answer 6

para js, el operador === devolverá verdadero si se usa en tipos de cadena y las cadenas son exactamente los mismos caracteres. Para objetos compara las referencias de objetos, no los contenidos.

De la norma ECMA :

11.9.6 El algoritmo de comparación de igualdad estricta La comparación x === y, donde x e y son valores, produce verdadero o falso. Tal comparación se realiza de la siguiente manera:

1. Si el Tipo (x) es diferente del Tipo (y), devuelva falso.
2. Si el Tipo (x) no está definido, devuelva verdadero.
3. Si el Tipo (x) es Nulo, devuelve verdadero.
4. Si el Tipo (x) es Número, entonces a. Si x es NaN, devuelve falso. segundo. Si y es NaN, devuelve falso. do. Si x es el mismo valor numérico que y, devuelva verdadero. re. Si x es +0 e y es -0, devuelve verdadero. mi. Si x es -0 e y es +0, devuelve verdadero. F. Falso retorno.
5. Si el Tipo (x) es Cadena, devuelva verdadero si x e y son exactamente la misma secuencia de caracteres (la misma longitud y los mismos caracteres en las posiciones correspondientes); de lo contrario, devuelve falso.
6. Si el Tipo (x) es Booleano, devuelve verdadero si x e y son verdaderos o falsos;