La fonction isNaN()
permet de déterminer si une valeur est NaN
. On notera que cette fonction utilise des règles de conversion différentes de Number.isNaN()
, défini avec ECMAScript 2015 (ES6). Il est aussi possible d'utiliser typeof
afin de déterminer si une valeur vaut NaN
(qui signifie « n'est pas un nombre »).
Syntaxe
isNaN(valeurÀTester)
Paramètres
valeurÀTester
- La valeur dont on souhaite déterminer si elle est
NaN
.
Valeur de retour
true
si la valeur fournie vaut NaN
, sinon, la méthode renverra false
.
Description
La nécessité d'avoir isNaN()
À 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 valeur est ou n'est pas réellement NaN
. En effet NaN == NaN
et NaN === NaN
renvoient false
tous les deux. C'est pour cela qu'il est nécessaire d'avoir la fonction isNaN()
.
Les origines de NaN
La valeur NaN
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 obtient NaN
. 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 pour isNaN()
, son comportement sur les arguments non-numériques a toujours été source de confusion. Lorsque l'argument passé à la fonction n'est pas du type Number, 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'est NaN
. 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 renverra false
, ce qui pourrait être inattendu (en effet, la chaîne vide n'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éthode Number.isNaN()
. Number.isNaN(x)
permettra de tester de façon plus fiable si x
vaut NaN
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 si x
vaut NaN
ou non (en effet le résultat de cette expression n'aura pas les faux positifs de isNaN
). Sous cet angle, isNaN()
peut être vu comme :
isNaN = function(valeur) { Number.isNaN(Number(valeur)); }
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 vaut NaN
, le résultat de l'expression sera NaN
également (on dit alors que NaN
« empoisonne » l'expression). La méthode isNaN()
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 être NaN
. 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 équivalente function incrémentCourt(x) { isNaN(x) ? 1 : x + 1; } incrément("blabla"); // 1 incrément(1); // 2 incrément(NaN); // 1
Exemples
isNaN(NaN); // true isNaN(undefined); // true isNaN({}); // true isNaN(true); // false isNaN(null); // false isNaN(37); // false // strings isNaN("37"); // false : "37" est converti vers le nombre 37 qui n'est pas NaN isNaN("37.37"); // false : "37.37" est converti vers le nombre 37.37 qui n'est pas NaN isNaN("123ABC"); // true : "123ABC" converti en 123 par parseInt mais en NaN par Number isNaN(""); // false : la chaîne vide est convertie en 0 qui n'est pas NaN isNaN(" "); // false : une chaîne de blancs est convertie en 0 qui n'est pas NaN // dates isNaN(new Date()); // false isNaN(new Date().toString()); // true // Voici le résultat « faux-positif » qui fait que isNaN n'est pas entièrement fiable isNaN("blabla") // true : "blabla" est converti en un nombre // Si on souhaite convertir cette valeur en nombre, cela échoue // et on obtient NaN
Spécifications
Spécification | État | Commentaires |
---|---|---|
ECMAScript 1st Edition (ECMA-262) | Standard | Définition initiale. |
ECMAScript 5.1 (ECMA-262) La définition de 'isNaN' dans cette spécification. |
Standard | |
ECMAScript 2015 (6th Edition, ECMA-262) La définition de 'isNaN' dans cette spécification. |
Standard | |
ECMAScript 2017 Draft (ECMA-262) La définition de 'isNaN' dans cette spécification. |
Projet |
Compatibilité des navigateurs
Fonctionnalité | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|
Support simple | (Oui) | (Oui) | (Oui) | (Oui) | (Oui) |
Fonctionnalité | Android | Chrome pour Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
---|---|---|---|---|---|---|
Support simple | (Oui) | (Oui) | (Oui) | (Oui) | (Oui) | (Oui) |