NaN

Exemple interactif

function sanitize(x) {
  if (isNaN(x)) {
    return NaN;
  }
  return x;
}

console.log(sanitize("1"));
// Sortie attendue : "1"

console.log(sanitize("NotANumber"));
// Sortie attendue : NaN

Valeur

La mme valeur numrique que Number.NaN.

Description

NaN est une proprit de l'objet global. En d'autres termes, c'est une variable dans la porte globale.

Dans les navigateurs modernes, NaN est une proprit non configurable et non modifiable. Mme lorsque ce n'est pas le cas, il faut viter de la surcharger.

Il existe cinq types d'oprations diffrents qui retournent NaN :

• Conversion de nombre choue (par exemple, explicitement comme parseInt("blabla"), Number(undefined), ou implicitement comme Math.abs(undefined))
• Opration mathmatique dont le rsultat n'est pas un nombre rel (par exemple, Math.sqrt(-1))
• Forme indtermine (par exemple, 0 * Infinity, 1 ** Infinity, Infinity / Infinity, Infinity - Infinity)
• Mthode ou expression dont l'oprande est ou devient contraint NaN (par exemple, 7 ** NaN, 7 * "blabla") cela signifie que NaN est contagieux
• Autres cas o une valeur invalide doit tre reprsente comme un nombre (par exemple, une Date invalide new Date("blabla").getTime(), "".charCodeAt(1))

NaN et ses comportements n'ont pas t invents par JavaScript. Sa smantique en arithmtique virgule flottante (y compris le fait que NaN !== NaN) est dfinie par IEEE 754 (angl.). Les comportements de NaN incluent :

• Si NaN intervient dans une opration mathmatique (mais pas dans les oprations bit bit), le rsultat est gnralement aussi NaN. (Voir le contre-exemple ci-dessous.)
• Lorsque NaN est l'un des oprandes d'une comparaison relationnelle (>, <, >=, <=), le rsultat est toujours false.
• NaN n'est gal (avec ==, !=, === et !==) aucune autre valeur y compris une autre valeur NaN.

NaN fait aussi partie des valeurs quivalentes faux en JavaScript.

Exemples

Tester les comparaisons avec NaN

Pour savoir si une valeur est NaN, utilisez Number.isNaN() ou isNaN() pour dterminer le plus clairement possible si une valeur est NaN ou, puisque NaN est la seule valeur qui se compare ingal elle-mme, vous pouvez effectuer une auto-comparaison comme x !== x.

NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true
Number.isNaN(NaN); // true

function valueIsNaN(v) {
  return v !== v;
}
valueIsNaN(1); // false
valueIsNaN(NaN); // true
valueIsNaN(Number.NaN); // true

Cependant, notez la diffrence entre isNaN() et Number.isNaN() : la premire retourne true si la valeur est actuellement NaN, ou si elle va devenir NaN aprs avoir t convertie en nombre, tandis que la seconde retourne true uniquement si la valeur est actuellement NaN :

isNaN("bonjour le monde"); // true
Number.isNaN("bonjour le monde"); // false

Pour la mme raison, l'utilisation d'une valeur BigInt gnrera une erreur avec isNaN() et non avec Number.isNaN() :

isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false

De plus, certaines mthodes de tableau ne peuvent pas trouver NaN, tandis que d'autres le peuvent. En particulier, celles qui recherchent un index (indexOf(), lastIndexOf()) ne peuvent pas trouver NaN, tandis que celles qui recherchent une valeur (includes()) le peuvent :

const arr = [2, 4, NaN, 12];
arr.indexOf(NaN); // -1
arr.includes(NaN); // true

// Les mthodes acceptant un prdicat correctement dfini peuvent toujours trouver NaN
arr.findIndex((n) => Number.isNaN(n)); // 2

Pour plus d'informations sur NaN et sa comparaison, voir Comparaison d'galit et identit.

Valeurs NaN distinctes observables

Il est possible de produire deux nombres virgule flottante ayant des reprsentations binaires diffrentes mais qui sont tous deux NaN, car dans le codage IEEE 754 (angl.), tout nombre virgule flottante avec un exposant 0x7ff et une mantisse non nulle est NaN. En JavaScript, il est possible de manipuler les bits l'aide des tableaux typs.

const f2b = (x) => new Uint8Array(new Float64Array([x]).buffer);
const b2f = (x) => new Float64Array(x.buffer)[0];
// Obtenir une reprsentation en octets de NaN
const n = f2b(NaN);
const m = f2b(NaN);
// Modifier le bit de signe, ce qui n'a pas d'importance pour NaN
n[7] += 2 ** 7;
// n[0] += 2**7; pour les processeurs gros-boutistes
const nan2 = b2f(n);
console.log(nan2); // NaN
console.log(Object.is(nan2, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan2)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 255]
// Modifier le premier bit, qui est le bit de poids faible de la mantisse et n'a pas d'importance pour NaN
m[0] = 1;
// m[7] = 1; pour les processeurs gros-boutistes
const nan3 = b2f(m);
console.log(nan3); // NaN
console.log(Object.is(nan3, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan3)); // Uint8Array(8) [1, 0, 0, 0, 0, 0, 248, 127]

chapper silencieusement NaN

NaN se propage travers les oprations mathmatiques, il est donc gnralement suffisant de tester la prsence de NaN une seule fois la fin du calcul pour dtecter les conditions d'erreur. Le seul cas o NaN est silencieusement chapp est lors de l'utilisation de l'exponentiation avec un exposant de 0, ce qui retourne immdiatement 1 sans tester la valeur de la base.

NaN ** 0 === 1; // true

Spcifications

Compatibilit des navigateurs

Voir aussi

• La proprit Number.NaN
• La mthode Number.isNaN()
• La fonction isNaN()