tratar - Velocidad de comparación con null vs undefined en JavaScript

undefined javascript error

Question

Acabo de ejecutar una prueba de rendimiento de JavaScript muy simple (no preguntes por qué). La prueba declara una variable, pero no le asigna nada:

var x;

Luego compara la velocidad de comparación de la variable de valor con null , y con undefined , en otras palabras:

var y = (x == null); y var y = (x == undefined); .

Esperaba que la comparación con undefined fuera el ayuno. De hecho, no estaba cerca. La comparación con null fue el más rápido, el 80% más rápido.

Los resultados que he descrito arriba provienen de ejecutar las pruebas en Chrome (versión 13). Ejecutarlos en Firefox produce resultados mucho más cercanos a lo que esperaba (la comparación con undefined es más rápido que con null , aunque de forma muy marginal).

Entonces, mi pregunta es ¿cuál podría ser la causa de esto? ¿Por qué Chrome parece favorecer la comparación con null tan grandemente?

Para una referencia rápida, aquí hay una captura de pantalla de los resultados:

Answer 1

Está comparando con la búsqueda de una variable llamada undefined (que devuelve un valor indefinido), por lo que no está haciendo lo que tenía previsto.

Hay formas de verificar si una variable no está definida. Como han mencionado los otros carteles, typeof x === ''undefined'' es uno. (Probablemente haya otra posibilidad que es algo como hasOwnProperty(''x'') ejecutado en el objeto global, pero que no verifica la cadena de alcance).

Answer 2

Recientemente descubrí que esto:

 if (typeof this._minLat === ''undefined'') {
   this._minLat = Math.min(...this.points.map(point => point.lat));
 }
 return this._minLat;

parece ser mucho más rápido que esto:

 return  this._minLat || Math.min(...this.points.map(point => point.lat));    

Answer 3

si pienso bien, no son lo mismo. por lo que no puede usar null en lugar de undefined.

typeof! == "undefined" vs.! = null

Answer 4

null es una palabra clave reservada que no se puede anular, por lo que cuando se compara con nulo, todo lo que se debe hacer es una sola comparación.

Sin embargo, cuando está comprobando en contra de lo undefined , el motor debe hacer una búsqueda de tipo y luego una comparación, lo que significa que en realidad es un poco más exigente.

Si necesita verificar realmente si algo no está definido, debe usar

if(typeof notSet == "undefined"){ }

Prueba

Pruébalo ... y configura algo para null en tu consola de JavaScript.

null = "will error";
// Errors with --> ReferenceError: invalid assignment left-hand side

Sin embargo, si intentas hacerlo con indefinido, no habrá error. Eso no quiere decir que puede anular undefined , porque no puede, pero ese undefined es su propio tipo primitivo.

La única similitud real entre nula e indefinida, es que ambos pueden ser coaccionados en un booleano falso.