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

Antes que nada quiero mencionar que sé cómo isNaN() y Number.isNaN() trabajar. Estoy leyendo La guía definitiva por David Flanagan y 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 la 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 por x !== x y false por x != x?

En primer lugar, 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 están necesariamente en IEEE-754, permite múltiples valores diferentes “no un número”). Es por eso que incluso surge esto; todos los demás valores en JavaScript son iguales a ellos mismos, NaN es simplemente especial.

… ¿me falta algún valor en JavaScript que devolverá verdadero para x !== x y falso para x != x?

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

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

1. Devolver si es abrupto (x).
2. ReturnIfAbrupt(y).

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

   Devuelve el resultado de realizar la Comparación de igualdad estricta x === y.

4. …

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

Entonces, si Flanagan tiene razón en que solo NaN dará verdad por x !== xpodemos estar seguros de que también es cierto que sólo NaN dará verdad para x != x.

Muchos programadores de JavaScript usan por defecto === y !== para evitar algunas trampas en torno al tipo de coerción que hacen los operadores flexibles, pero no hay nada que leer en el uso de Flanagan del operador estricto frente al operador flexible en este caso.

A efectos de NaN, != y !== hacer la misma cosa.

Sin embargo, muchos programadores evitan == o != en JavaScript. Por ejemplo, Douglas Crockford los considera entre los “partes malas” del lenguaje JavaScript porque se comportan de formas inesperadas y confusas:

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

… Mi consejo es nunca usar a los gemelos malvados. En su lugar, utilice siempre === y !==.

Solo por diversión, déjame mostrarte un ejemplo artificial donde x no es NaN pero los operadores se comportan de manera diferente de todos modos. Primero define:

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

Entonces tenemos

x != x // false

pero

x !== x // true

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

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 coerción de tipos, pero al igual que en otros lenguajes y a la par del estándar, NaN indica una falla 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 esto 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á de acuerdo con eso.

Como a veces, las imágenes son mejores que las palabras, mira esto mesa (que es la razón por la que hago de esto una respuesta en lugar de un comentario porque tiene 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 ECMAlo que JavaScript considera al comparar, de manera que el siguiente código se evalúe como verdadero.

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