javascript - triple - signo igual con 3 lineas ≡

Diferencia de rendimiento de JavaScript entre doble igual(==) y triple igual(===)

Question

En JavaScript, ¿hay una diferencia de rendimiento entre usar un doble igual ( == ) vs usar un triple igual ( === )?

Ejemplo: if (foo == bar) vs if (foo === bar)

Answer 1

A partir de algunas pruebas endebles, == parece ser marginalmente más rápido que === .

De manera marginal, quiero decir que puedo ver una diferencia de unos pocos milisegundos en las interacciones de muchos millones de pruebas. No es posible que necesite la ganancia de rendimiento, en lugar de usar lo que sea más correcto para la tarea en cuestión.

EDITAR: en realidad, parece depender de / what / you''re comparison y de la implementación del navegador. En otras palabras, no te preocupes por eso.

Answer 2

Debido al rendimiento, creo que === tiene un mejor rendimiento, porque === es más estricto que == ,

por ejemplo, intente lo siguiente en la consola de Chrome.

> 1 == ''1''
  true
> 1 === ''1''
  false

== tiene que verificar más cosas que ===

Answer 3

La comparación estricta ( === ) siempre será un poco más rápida, pero la diferencia generalmente es insignificante .

Definitivamente tiene sentido preferir === si sabes con certeza que no necesitas coerción de tipo en la comparación. Siempre será al menos tan rápido como == .

Answer 4

Editar: para referencia aquí está la explicación de la especificación por el Dr. Axel Rauschmayer http://www.2ality.com/2011/06/javascript-equality.html Realmente genial escribir.

=== (Igualdad estricta): solo considera valores iguales que tienen el mismo tipo.

1. undefined === undefined, null === null,
2. NaN === nada incluido a sí mismo,
3. Primitivo [Número | Cadena | Booleano] === Valor primitivo igual,
4. a uno mismo (+0 === -0)
5. Dos objetos [Array | Object | Function] === Only self (misma entidad exacta)

== (Igualdad Lento)

1. Si ambos valores tienen el mismo tipo: compare con ===.
2. undefined == null
3. número y cadena: cadena => número y comparar
4. booleano y no booleano => no booleano para numerar y comparar
5. cadena o número => un objeto: convertir objeto a primitivo y comparación.

En todos los entornos de Javascript modernos se implementan completamente diferentes. En términos simples, == prueba la igualdad mediante la conversión de variables dadas en primitivas (cadena, número, booleano). === prueba la uniformidad estricta, lo que significa exactamente el mismo Objeto o valor primitivo sin conversión.

Si objOne == objTwo lo que realmente sucede es [[EQUALS]].call(objOne.valueOf(), objTwo.valueOf())

La resolución de valueOf puede estar algo involucrada, rebotando entre funciones expuestas en JS y cosas internas del motor. Baste decir que la comparación siempre terminará con dos valores forzados a primitivos o se lanzará un error.

Editar: STRICT_EQUALS realmente intenta STRICT_EQUALS primero, lo que previene el resto del proceso.

Lo interesante aquí es que valueOf (y su socio toString) son invalidables. Ejecuta este fragmento de código en Chrome (creo que cualquier webkit, no estoy seguro si JSC y V8 comparten este tidbit). Va a hacer volar tu mente:

var actions = [];
var overload = {
  valueOf: function(){
    var caller = arguments.callee.caller;
    actions.push({
      operation: caller.name,
      left: caller.arguments[0] === this ? "unknown" : this,
      right: caller.arguments[0]
    });
    return Object.prototype.toString.call(this);
  }
};
overload.toString = overload.valueOf;
overload == 10;
overload === 10;
overload * 10;
10 / overload;
overload in window;
-overload;
+overload;
overload < 5;
overload > 5;
[][overload];
overload == overload;
console.log(actions);

Salida:

[ { operation: ''EQUALS'',
    left: overload,
    right: 10 },
  { operation: ''MUL'',
    left: overload,
    right: 10 },
  { operation: ''DIV'',
    left: ''unknown'',
    right: overload },
  { operation: ''IN'',
    left: overload,
    right: DOMWindow },
  { operation: ''UNARY_MINUS'',
    left: overload,
    right: undefined },
  { operation: ''TO_NUMBER'',
    left: overload,
    right: undefined },
  { operation: ''COMPARE'',
    left: overload,
    right: 5 },
  { operation: ''COMPARE'',
    left: ''unknown'',
    right: overload },
  { operation: ''ToString'',
    left: ''unknown'',
    right: overload } ]

La esencia de la diferencia entre == y === se ilustra con === no aparece en esa lista. Se salta el viaje a JavascriptLand por completo. Esa aventura es costosa cuando se compara el rendimiento.

Sin embargo, debe tener en cuenta las optimizaciones del motor. Para la mayoría de los objetos, el motor podrá cortar la mayoría de los pasos y permanecer en NativeLand y obtener casi el mismo rendimiento. Pero esto no es una garantía y si algo impide que el motor pueda utilizar las optimizaciones, algo de sofisticación en su código o anular las construcciones internas o una miríada de problemas, entonces verá el resultado en forma instantánea. === fuerza.

=== es casi lo único inmutable en Javascript.

Answer 5

• Si los tipos comparados son iguales, son idénticos . Es decir, usan el mismo algoritmo exacto .

• Si los tipos son diferentes , entonces el rendimiento es irrelevante. O necesitas coerción tipo, o no. Si no lo necesita, no use == porque el resultado que obtiene puede ser inesperado.