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 même valeur numérique que Number.NaN.

Description

NaN est une propriété de l'objet global. En d'autres termes, c'est une variable dans la portée globale.

Dans les navigateurs modernes, NaN est une propriété non configurable et non modifiable. Même lorsque ce n'est pas le cas, il faut éviter de la surcharger.

Il existe cinq types d'opérations différents qui retournent NaN :

• Conversion de nombre échouée (par exemple, explicitement comme parseInt("blabla"), Number(undefined), ou implicitement comme Math.abs(undefined))
• Opération mathématique dont le résultat n'est pas un nombre réel (par exemple, Math.sqrt(-1))
• Forme indéterminée (par exemple, 0 * Infinity, 1 ** Infinity, Infinity / Infinity, Infinity - Infinity)
• Méthode ou expression dont l'opérande 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 représentée comme un nombre (par exemple, une Date invalide new Date("blabla").getTime(), "".charCodeAt(1))

NaN et ses comportements n'ont pas été inventés par JavaScript. Sa sémantique en arithmétique à virgule flottante (y compris le fait que NaN !== NaN) est définie par IEEE 754 ^(angl.). Les comportements de NaN incluent :

• Si NaN intervient dans une opération mathématique (mais pas dans les opérations bit à bit), le résultat est généralement aussi NaN. (Voir le contre-exemple ci-dessous.)
• Lorsque NaN est l'un des opérandes d'une comparaison relationnelle (>, <, >=, <=), le résultat 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 déterminer le plus clairement possible si une valeur est NaN — ou, puisque NaN est la seule valeur qui se compare inégal à elle-même, 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 différence entre isNaN() et Number.isNaN() : la première retourne true si la valeur est actuellement NaN, ou si elle va devenir NaN après 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 même raison, l'utilisation d'une valeur BigInt générera 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 méthodes 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 méthodes acceptant un prédicat correctement défini 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 représentations binaires différentes 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 typés.

const f2b = (x) => new Uint8Array(new Float64Array([x]).buffer);
const b2f = (x) => new Float64Array(x.buffer)[0];
// Obtenir une représentation 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 opérations mathématiques, il est donc généralement suffisant de tester la présence de NaN une seule fois à la fin du calcul pour détecter 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 immédiatement 1 sans tester la valeur de la base.

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

Spécifications

Compatibilité des navigateurs

Voir aussi

• La propriété Number.NaN
• La méthode Number.isNaN()
• La fonction isNaN()