JavaScript Propriété NaN de l'objet global


Exemple

NaN (" N ot a N umber") est une valeur spéciale définie par la norme IEEE pour l'arithmétique en virgule flottante , qui est utilisée lorsqu'une valeur non numérique est fournie, mais qu'un nombre est attendu ( 1 * "two" ), ou lorsqu'un calcul n'a pas de résultat de number valide ( Math.sqrt(-1) ).

Toute égalité ou comparaison relationnelle avec NaN renvoie false , même en la comparant à elle-même. Parce que, NaN est supposé dénoter le résultat d’un calcul absurde, et en tant que tel, il n’est pas égal au résultat d’autres calculs absurdes.

(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

Les comparaisons non égales renvoient toujours true :

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

Vérifier si une valeur est NaN

6

Vous pouvez tester une valeur ou une expression pour NaN en utilisant la fonction 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

Vous pouvez vérifier si une valeur est NaN en la comparant à elle-même:

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

Vous pouvez utiliser le polyfill suivant pour Number.isNaN() :

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

En revanche, la fonction globale isNaN() renvoie true non seulement pour NaN , mais aussi pour toute valeur ou expression qui ne peut pas être forcée dans un nombre:

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 définit un algorithme de «similitude» appelé SameValue qui, depuis ECMAScript 6, peut être Object.is avec Object.is . Contrairement à la comparaison == et === , l'utilisation d' Object.is() traitera NaN comme identique à lui-même (et -0 comme pas identique à +0 ):

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

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

Vous pouvez utiliser le polyfill suivant pour Object.is() (à partir de 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;
    }
  };
}

Points à noter

NaN lui-même est un nombre, ce qui signifie qu'il n'est pas égal à la chaîne "NaN", et le plus important (mais peut-être de manière non intuitive):

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