statement - nan value javascript

¿Cuál es la diferencia entre(NaN!=NaN) y(NaN!== NaN)?

Question

En primer lugar, quiero mencionar que sé cómo funcionan isNaN() y Number.isNaN() . Estoy leyendo La guía definitiva de David Flanagan y él da un ejemplo de cómo verificar si el valor es NaN :

x !== x

Esto resultará en true si y solo si x es NaN .

Pero ahora tengo una pregunta: ¿por qué usa una comparación estricta? Porque parece que

x != x

se comporta de la misma manera. ¿Es seguro usar ambas versiones, o me faltan algunos valores en JavaScript que devolverán true para x !== x y false para x != x ?

Answer 1

Como a veces, las imágenes son mejores que las palabras, revise esta table (que es la razón por la que hago de esto una respuesta en lugar de un comentario es porque obtiene una mejor visibilidad)

Allí puede ver que la comparación de igualdad estricta (===) solo devuelve verdadero si el tipo y el contenido coinciden, por lo que

var f = "-1" === -1; //false

Mientras que la comparación de igualdad abstracta (==) verifica solo el contenido * al convertir tipos y luego compararlos estrictamente:

var t = "-1" == -1; //true

Aunque no está claro, sin consultar a ECMA , lo que JavaScript considera al comparar, de una manera que el siguiente código evalúa como verdadero.

 var howAmISupposedToKnowThat = [] == false; //true

Answer 2

Para los propósitos de NaN,! != Y !== haz lo mismo.

Sin embargo, muchos programadores evitan == o != En JavaScript. Por ejemplo, Douglas Crockford los considera entre las " partes malas " del lenguaje JavaScript porque se comportan de maneras inesperadas y confusas:

JavaScript tiene dos conjuntos de operadores de igualdad: === y !== , y sus gemelos malvados == y != . Los buenos funcionan de la manera que cabría esperar.

... Mi consejo es que nunca uses a los gemelos malvados. En su lugar, use siempre === y !== .

Answer 3

Primero, permítanme señalar que NaN es un valor muy especial: por definición, no es igual a sí mismo. Eso proviene del estándar IEEE-754 en el que se basan los números de JavaScript. El valor "no es un número" nunca es igual a sí mismo, incluso cuando los bits coinciden exactamente. (Que no son necesariamente en IEEE-754, permite múltiples valores diferentes "no un número"). Es por eso que incluso aparece; todos los demás valores en JavaScript son iguales a sí mismos, NaN es simplemente especial.

... ¿me falta algún valor en JavaScript que devuelva verdadero para x! == x y falso para x! = x?

No tu no eres. La única diferencia entre !== y != Es que este último hará una coerción de tipo si es necesario para que los tipos de operandos sean los mismos. En x != x , los tipos de los operandos son los mismos, por lo que es exactamente igual a x !== x .

Esto queda claro desde el comienzo de la definición de la Operación de igualdad abstracta :

1. ReturnIfAbrupt (x).
2. ReturnIfAbrupt (y).

3. Si el Tipo (x) es el mismo que el Tipo (y), entonces

   Devuelve el resultado de realizar una estricta comparación de igualdad x === y.

4. ...

Los primeros dos pasos son fontanería básica. En efecto, el primer paso de == es ver si los tipos son los mismos y, de ser así, hacer === lugar. != y !== son solo versiones negadas de eso.

Entonces, si Flanagan tiene razón en que solo NaN dará verdadero para x !== x , podemos estar seguros de que también es cierto que solo NaN dará verdadero para x != x

Muchos programadores de JavaScript usan de manera predeterminada === y !== para evitar algunas dificultades en torno a la coerción de tipo que hacen los operadores sueltos, pero no hay nada que leer sobre el uso de Flanagan del operador estricto frente al operador suelto en este caso.

Answer 4

Solo por diversión, permíteme mostrarte un ejemplo artificial donde x no es NaN pero los operadores se comportan de manera diferente de todos modos. Primero defina:

Object.defineProperty(
self,
''x'',
{ get: function() { return self.y = self.y ? 0 : ''0''; } }
);

Entonces nosotros tenemos

x != x // false

pero

x !== x // true

Answer 5

Solo quiero señalar que NaN no es lo único que produce x !== x sin usar el objeto global. Hay muchas formas inteligentes de desencadenar este comportamiento. Aquí hay uno que usa getters:

var i = 0, obj = { get x() { return i++; }};
with(obj) // force dynamic context, this is evil.
console.log(x === x); // false

Como señalan otras respuestas, == realiza una coerción de tipo, pero en igual que en otros idiomas y a la par del estándar: NaN indica un error de cálculo, y por buenas razones no es igual a sí mismo.

Por alguna razón más allá de mí, la gente considera que este es un problema con JS, pero la mayoría de los lenguajes que tienen dobles (es decir, C, Java, C ++, C #, Python y otros) exhiben este comportamiento exacto y la gente está bien con eso.