isNaN()

Baseline Widely available

Cette fonctionnalité est bien établie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis ⁨juillet 2015⁩.

La fonctionisNaN() permet de déterminer si une valeur estNaN. On notera que cette fonction utilise des règles de conversion différentes deNumber.isNaN(), définie avec ECMAScript 2015 (ES6).

Exemple interactif

function milliseconds(x) {  if (isNaN(x)) {    return "Not a Number!";  }  return x * 1000;}console.log(milliseconds("100F"));// Expected output: "Not a Number!"console.log(milliseconds("0.0314E+2"));// Expected output: 3140

Syntaxe

isNaN(valeurÀTester);

Paramètres

valeurÀTester: La valeur dont on souhaite déterminer si elle estNaN.

Valeur de retour

true si la valeur fournie vautNaN, sinon, la méthode renverrafalse.

À la différence des autres valeurs JavaScript, il est impossible d'utiliser les opérateurs d'égalité faible et stricte (== et===) afin de déterminer si une valeurest oun'est pas réellementNaN. En effetNaN == NaN etNaN === NaN renvoientfalse tous les deux. C'est pour cela qu'il est nécessaire d'avoir la fonctionisNaN().

Les origines de`NaN`

La valeurNaN est générée lorsqu'une opération arithmétique résulte en une valeur indéfinie ou non représentable. De telles valeurs ne représentent pas nécessairement des dépassements de condition.NaN peut également être le résultat d'une conversion numérique pour les valeurs qui n'ont pas de valeurs numériques correspondantes (par exemple lorsqu'on souhaite convertir la chaîne"toto" en un nombre).

Par exemple, lorsqu'on divise zéro par zéro, on obtientNaN. En revanche, lorsqu'on divise d'autres nombres par zéro, on n'obtient pas ce résultat.

Comportement étrange de`isNaN()`

Depuis les premières spécifications pourisNaN(), son comportement sur les arguments non-numériques a toujours été source de confusion. Lorsque l'argument passé à la fonction n'est pas du typeNumber, la valeur est d'abord convertie en une valeur du type Number. La valeur résultante est ensuite utilisée lors du test afin de déterminer si c'estNaN. Ainsi pour valeurs non numériques qui sont converties en une valeur non-NaN numérique (notamment la chaîne vide, les valeurs booléennes qui donnent zéro ou un), la fonction renverrafalse, ce qui pourrait être inattendu (en effet, la chaîne viden'est pas un nombre). Ici, la confusion provient du fait que « not a number » a un sens particulier pour les valeurs numériques représentées selon IEEE-754. Cette fonction doit plutôt être vue comme la réponse à la question « est-ce que cette valeur, lorsqu'elle est convertie en une valeur numérique, correspond à la valeur IEEE-754 "Not A Number" ? ».

La version ECMAScript ES2015 ajoute la méthodeNumber.isNaN().Number.isNaN(x) permettra de tester de façon plus fiable six vautNaN ou non. Si on ne dispose pas de cette méthode, on peut également utiliser l'expression(x != x) afin de tester de façon plus certaine six vautNaN ou non (en effet le résultat de cette expression n'aura pas les faux positifs deisNaN). Sous cet angle,isNaN() peut être vu comme :

var isNaN = function (valeur) {  return Number.isNaN(Number(valeur));};

Ou encore, en utilisant le fait queNaN est la seule valeur différente d'elle-même :

var isNaN = function (valeur) {  var n = Number(valeur);  return n !== n;};

`NaN` est « empoisonné »

Cette fonction peut être utilisée afin de déterminer si la valeur courante peut faire partie d'une expression arithmétique. En effet, si un des composants d'une expression arithmétique vautNaN, le résultat de l'expression seraNaN également (on dit alors queNaN « empoisonne » l'expression). La méthodeisNaN() permet alors de vérifier, avant de construire une expression, que les valeurs utilisées n'empoisonneront pas l'expression.

On peut par exemple construire une fonction dont on souhaite qu'elle incrémente l'argument et que la valeur qu'elle renvoie ne puisse pas êtreNaN. Le code de cette fonction pourrait être :

function incrément(x) {  if (isNaN(x)) {    x = 0;  }  return x + 1;}// En utilisant des notations raccourcies,// on pourrait écrire une fonction équivalentefunction incrémentCourt(x) {  isNaN(x) ? 1 : x + 1;}incrément("blabla"); // 1incrément(1); // 2incrément(NaN); // 1

Exemples

isNaN(NaN); // trueisNaN(undefined); // trueisNaN({}); // trueisNaN(true); // falseisNaN(null); // falseisNaN(37); // false// stringsisNaN("37"); // false : "37" est converti vers le nombre 37 qui n'est pas NaNisNaN("37.37"); // false : "37.37" est converti vers le nombre 37.37 qui n'est pas NaNisNaN("37,25"); // true  : la virgule n'est pas considérée comme un séparateur décimalisNaN("123ABC"); // true  : "123ABC" converti en 123 par parseInt mais en NaN par NumberisNaN(""); // false : la chaîne vide est convertie en 0 qui n'est pas NaNisNaN(" "); // false : une chaîne de blancs est convertie en 0 qui n'est pas NaN// datesisNaN(new Date()); // falseisNaN(new Date().toString()); // true// Voici le résultat « faux-positif » qui fait que isNaN n'est pas entièrement fiableisNaN("blabla"); // true : "blabla" est converti en un nombre// Si on souhaite convertir cette valeur en nombre, cela échoue// et on obtient NaN