NaN en JavaScript

1. Qu'est-ce que NaN
2. Quand NaN sera-t-il restitué
3. Juge NaN
4. Référence

Qu'est-ce que NaN

Décrit dans l'article NaN de MDN :
• L'attribut global NaN représente la valeur de Not-A-Number.
• NaN est une propriété d'un objet global.
• La valeur initiale de l'attribut NaN est NaN, identique à la valeur de Number.NaN.
• Math.sqrt(-1)Dans ES5, l'attribut NaN est un attribut non configurable et non inscriptible. Mais dans ES3, la valeur de cette propriété peut être modifiée, mais l'écrasement doit être évité. parseInt("blabla")
apparaît généralement comme la valeur de retour d'une méthode mathématique lorsqu'un calcul échoue (par exemple :

) ou lorsque vous essayez d'analyser une chaîne en un nombre mais échoue (par exemple :

NaNType NaN Number

typeof NaN   // "number"

est une valeur de type

Le chapitre "3.1.3 Opérations arithmétiques en JavaScript" du Guide définitif de JavaScript a une description : NaN

sera renvoyé en prenant la racine carrée de tout nombre négatif ou en utilisant un opérateur arithmétique avec un opérande qui n'est pas un nombre ou ne peut pas être converti en nombre.

• peut être interprété séparément comme les situations suivantes :
• L'infini divisé par l'infini
• Faites l'opération racine carrée pour tout nombre négatif
• Opérateurs arithmétiques utilisés avec des opérandes qui ne sont pas des nombres ou ne peuvent pas être convertis en nombres

La chaîne est analysée en un nombreNaN

Les résultats suivants sont tous

Infinity / Infinity;   // 无穷大除以无穷大
Math.sqrt(-1);         // 给任意负数做开方运算
'a' - 1;               // 算数运算符与不是数字或无法转换为数字的操作数一起使用
'a' * 1;
'a' / 1;
parseInt('a');         // 字符串解析成数字
parseFloat('a');

Math.sqrt('4');        // 2
2 * '2';               // 4
'4' / 2;               // 2

conversion de type JavaScript

Le chapitre "3.8 Conversion de type" du Guide définitif JavaScript décrit :

Si JavaScript attend un nombre, il convertira la valeur donnée en nombre (si le résultat de la conversion n'a aucun sens, renvoie NaN). Number()

Vous pouvez utiliser la méthode + pour une conversion de type explicite, par exemple :

Number('1');           // 1
Number(null);          // 0
Number('a');           // NaN

Vous pouvez également utiliser l'opérateur unaire parseInt() pour une conversion implicite, par exemple : parseFloat()

+'1';                  // 1
+null;                 // 0
+'a';                  // NaN

et parseInt() pour analyser des entiers et des nombres à virgule flottante : parseFloat()

parseInt('12');        // 12
parseInt('12a');       // 12
parseInt('a12');       // NaN
parseInt(null);        // NaN

et

peuvent être simplement compris comme : NaN

Number()parseInt()``parseFloat()null Il est à noter que

, certaines valeurs d'entrée sont traitées différemment, comme

Convertir les types non numériques en types numériques, comme résumé dans le tableau suivant :

isNaN()Comment juger NaNNaN

global La fonction ne peut pas juger strictement si la valeur d'entrée est isNaN().

comportement étrange

paramètre non numérique

 : NaN

.

NaNfalse

Par conséquent, il peut être déroutant de renvoyer une valeur

qui peut être contrainte à une valeur valide.

isNaN('37');      // false: 可以被转换成数值 37
isNaN('');        // false: 空字符串被转换成 0

Référez-vous au code Polyfill de dans MDN :

typeof value === 'number' && isNaN(value)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!