JavaScript Proprietà NaN dell'oggetto globale


Esempio

NaN (" N ot a N umber") è un valore speciale definito dallo standard IEEE per l'aritmetica virgola mobile , che viene utilizzato quando viene fornito un valore non numerico, ma un numero è previsto ( 1 * "two" ) o quando un calcolo non ha un risultato number valido ( Math.sqrt(-1) ).

Qualsiasi paragone di uguaglianza o di relazione con NaN restituisce un valore false , anche confrontandolo con se stesso. Perché, si suppone che NaN denoti il ​​risultato di un calcolo insensato e, in quanto tale, non è uguale al risultato di altri calcoli privi di senso.

(1 * "two") === NaN  //false

NaN === 0;          // false
NaN === NaN;        // false
Number.NaN === NaN; // false

NaN < 0;            // false
NaN > 0;            // false
NaN > 0;            // false
NaN >= NaN;         // false
NaN >= 'two';       // false

I confronti non uguali restituiranno sempre true :

NaN !== 0;          // true
NaN !== NaN;        // true

Verifica se un valore è NaN

6

È possibile testare un valore o un'espressione per NaN utilizzando la funzione Number.isNaN () :

Number.isNaN(NaN);         // true
Number.isNaN(0 / 0);       // true
Number.isNaN('str' - 12);  // true

Number.isNaN(24);          // false
Number.isNaN('24');        // false
Number.isNaN(1 / 0);       // false
Number.isNaN(Infinity);    // false

Number.isNaN('str');       // false
Number.isNaN(undefined);   // false
Number.isNaN({});          // false
6

Puoi verificare se un valore è NaN confrontandolo con se stesso:

value !== value;    // true for NaN, false for any other value

È possibile utilizzare il seguente polyfill per Number.isNaN() :

Number.isNaN = Number.isNaN || function(value) {     
    return value !== value;
}

Al contrario, la funzione globale isNaN() restituisce true non solo per NaN , ma anche per qualsiasi valore o espressione che non può essere forzato in un numero:

isNaN(NaN);         // true
isNaN(0 / 0);       // true
isNaN('str' - 12);  // true

isNaN(24);          // false
isNaN('24');        // false
isNaN(Infinity);    // false

isNaN('str');       // true
isNaN(undefined);   // true
isNaN({});          // true

ECMAScript definisce un algoritmo di "uguaglianza" chiamato SameValue che, dal momento che ECMAScript 6, può essere richiamato con Object.is . A differenza del confronto == e === , l'uso di Object.is() considera NaN identico a se stesso (e -0 come non identico a +0 ):

Object.is(NaN, NaN)      // true
Object.is(+0, 0)         // false

NaN === NaN              // false
+0 === 0                 // true
6

È possibile utilizzare il seguente polyfill per Object.is() (da MDN ):

if (!Object.is) {
  Object.is = function(x, y) {
    // SameValue algorithm
    if (x === y) { // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  };
}

Punti da notare

NaN stesso è un numero, il che significa che non è uguale alla stringa "NaN" e, cosa più importante (anche se forse non intuitivamente):

typeof(NaN) === "number"; //true