Pourquoi typeof NaN renvoie-t-il 'nombre'?

Juste par curiosité.

Il ne semble pas très logique que ce typeof NaNsoit le nombre. Juste comme NaN === NaNou NaN == NaNretournant faux, au fait. Est-ce l'une des particularités de javascript, ou y aurait-il une raison à cela?

Edit: merci pour vos réponses. Ce n'est cependant pas une chose facile à faire. En lisant les réponses et le wiki, j'ai mieux compris, mais quand même, une phrase comme

Une comparaison avec un NaN renvoie toujours un résultat non ordonné même en comparant avec lui-même. Les prédicats de comparaison sont soit de signalisation soit non de signalisation, les versions de signalisation signalent une exception invalide pour de telles comparaisons. Les prédicats d'égalité et d'inégalité ne sont pas de signalisation, donc x = x retournant false peut être utilisé pour tester si x est un NaN silencieux.

garde juste ma tête qui tourne. Si quelqu'un peut traduire cela dans un langage lisible par l'homme (par opposition à, disons, un mathématicien), je serais reconnaissant.

Cela signifie pas un nombre. Ce n'est pas une particularité de javascript mais un principe informatique commun.

Depuis http://en.wikipedia.org/wiki/NaN :

Il existe trois types d'opérations qui renvoient NaN:

Opérations avec un NaN comme au moins un opérande

Formes indéterminées

• Les divisions 0/0, ∞ / ∞, ∞ / −∞, −∞ / ∞ et −∞ / −∞
• Les multiplications 0 × ∞ et 0 × −∞
• La puissance 1 ^ ∞
• Les additions ∞ + (−∞), (−∞) + ∞ et soustractions équivalentes.

Des opérations réelles avec des résultats complexes:

• La racine carrée d'un nombre négatif
• Le logarithme d'un nombre négatif
• La tangente d'un multiple impair de 90 degrés (ou π / 2 radians)
• Le sinus ou cosinus inverse d'un nombre inférieur à -1 ou supérieur à +1.

Toutes ces valeurs peuvent ne pas être les mêmes. Un test simple pour un NaN est de tester value == valueest faux.

Eh bien, NaNc'est toujours un type numérique , malgré le fait qu'il signifie en fait Not-A-Number :-)

NaNsignifie simplement que la valeur spécifique ne peut pas être représentée dans les limites du type numérique (bien que cela puisse être dit pour tous les nombres qui doivent être arrondis pour s'adapter, mais NaNc'est un cas particulier).

Un spécifique NaNn'est pas considéré comme égal à un autre NaNcar il peut s'agir de valeurs différentes. Cependant, NaNc'est toujours un type de nombre, tout comme 2718 ou 31415.

Quant à votre question mise à jour à expliquer en termes simples:

Une comparaison avec un NaN renvoie toujours un résultat non ordonné même en comparant avec lui-même. Les prédicats de comparaison sont soit de signalisation soit non de signalisation, les versions de signalisation signalent une exception invalide pour de telles comparaisons. Les prédicats d'égalité et d'inégalité ne sont pas de signalisation, donc x = x retournant false peut être utilisé pour tester si x est un NaN silencieux.

Tout cela signifie (décomposé en parties):

Une comparaison avec un NaN renvoie toujours un résultat non ordonné même en comparant avec lui-même.

Fondamentalement, a NaNn'est égal à aucun autre nombre, y compris un autre NaN, et même lui- même inclus .

Les prédicats de comparaison sont soit de signalisation soit non de signalisation, les versions de signalisation signalent une exception invalide pour de telles comparaisons.

Tenter d'effectuer des opérations de comparaison (inférieure à, supérieure à, etc.) entre un NaNnombre et un autre nombre peut soit entraîner la levée d'une exception (signalisation), soit simplement devenir fausse (sans signalisation ou silencieuse).

Les prédicats d'égalité et d'inégalité ne sont pas de signalisation, donc x = x retournant false peut être utilisé pour tester si x est un NaN silencieux.

Les tests d'égalité (égal à, différent de) ne signalent jamais, donc leur utilisation ne provoquera pas d'exception. Si vous avez un numéro régulier x, ce x == xsera toujours vrai. Si xest a NaN, alors x == xsera toujours faux. Cela vous donne un moyen de détecter NaNfacilement (tranquillement).

La norme ECMAScript (JavaScript) spécifie qu'il Numberss'agit de flottants IEEE 754 , qui incluent NaNcomme valeur possible.

ECMA 262 5e Section 4.3.19 : Valeur numérique

valeur primitive correspondant à une valeur IEEE 754 au format binaire 64 bits double précision.

ECMA 262 5e Section 4.3.23 : NaN

Valeur numérique qui est une valeur IEEE 754 «Not-a-Number».

IEEE 754 sur Wikipedia

La norme IEEE pour l'arithmétique en virgule flottante est une norme technique établie par l'Institut des ingénieurs électriciens et électroniciens et la norme la plus largement utilisée pour le calcul en virgule flottante [...]

La norme définit

• formats arithmétiques : ensembles de données à virgule flottante binaires et décimales, constitués de nombres finis (y compris les zéros signés et les nombres inférieurs à la normale), les infinis et les valeurs spéciales «pas un nombre» (NaN)

[...]

typeof NaNretourne 'number'parce que:

• La spécification ECMAScript indique que le type Number inclut NaN:

  4.3.20 Type de numéro

  ensemble de toutes les valeurs numériques possibles, y compris les valeurs spéciales «Not-a-Number» (NaN), l'infini positif et l'infini négatif

• Donc typeofretourne en conséquence:

  11.4.3 Le type d'opérateur

  La production UnaryExpression : typeof UnaryExpression est évaluée comme suit:

  1. Soit val le résultat de l'évaluation de UnaryExpression .
  2. Si Type ( val ) est Reference , alors
     1. Si IsUnresolvableReference ( val ) est vrai , retournez "undefined".
     2. Laissez val être GetValue ( val ).
  3. Renvoyer une chaîne déterminée par type ( val ) selon le Tableau 20.
     

                  Table 20 — typeof Operator Results
  ==================================================================
  |        Type of val         |              Result               |
  ==================================================================
  | Undefined                  | "undefined"                       |
  |----------------------------------------------------------------|
  | Null                       | "object"                          |
  |----------------------------------------------------------------|
  | Boolean                    | "boolean"                         |
  |----------------------------------------------------------------|
  | Number                     | "number"                          |
  |----------------------------------------------------------------|
  | String                     | "string"                          |
  |----------------------------------------------------------------|
  | Object (native and does    | "object"                          |
  | not implement [[Call]])    |                                   |
  |----------------------------------------------------------------|
  | Object (native or host and | "function"                        |
  | does implement [[Call]])   |                                   |
  |----------------------------------------------------------------|
  | Object (host and does not  | Implementation-defined except may |
  | implement [[Call]])        | not be "undefined", "boolean",    |
  |                            | "number", or "string".            |
  ------------------------------------------------------------------

Ce comportement est conforme à la norme IEEE pour l'arithmétique à virgule flottante (IEEE 754) :

4.3.19 Valeur numérique

valeur primitive correspondant à une valeur IEEE 754 au format binaire 64 bits double précision

4.3.23 NaN

valeur numérique qui est une valeur IEEE 754 «Not-a-Number»

8.5 Le type de nombre

Le type Number a exactement 18437736874454810627 (c'est-à-dire 2 ⁵³ -2 ⁶⁴ +3) valeurs, représentant les valeurs IEEE 754 au format 64 bits double précision comme spécifié dans la norme IEEE pour l'arithmétique binaire à virgule flottante, sauf que le 9007199254740990 ( c'est-à-dire 2 ⁵³ -2) les valeurs distinctes «Not-a-Number» de la norme IEEE sont représentées dans ECMAScript comme une valeur NaN spéciale unique . (Notez que la valeur NaN est produite par l'expression de programme NaN.)

NaN est une valeur à virgule flottante valide ( http://en.wikipedia.org/wiki/NaN )

et NaN === NaN est faux car ils ne sont pas nécessairement le même non-nombre

NaN != NaNcar ils ne sont pas nécessairement le même non-nombre. Cela a donc beaucoup de sens ... Aussi pourquoi les flottants ont à la fois +0,00 et -0,00 qui ne sont pas les mêmes. L'arrondi peut faire qu'ils ne sont en fait pas nuls.

Quant au typeof, cela dépend de la langue. Et la plupart des langages diront que NaN est un flottant, un double ou un nombre selon la façon dont ils le classent ... Je ne connais aucun langage qui dira que c'est un type inconnu ou nul.

NaNsignifie Pas un nombre . Il s'agit d'une valeur de types de données numériques (généralement des types à virgule flottante, mais pas toujours) qui représente le résultat d'une opération non valide telle que la division par zéro.

Bien que ses noms indiquent qu'il ne s'agit pas d'un nombre, le type de données utilisé pour le contenir est un type numérique. Donc, en JavaScript, demander le type de données de NaNretournera number(comme alert(typeof(NaN))le montre clairement).

Javascript utilise NaN pour représenter tout ce qu'il rencontre qui ne peut pas être représenté autrement par ses spécifications. Cela ne veut pas dire que ce n'est pas un nombre. C'est simplement la manière la plus simple de décrire la rencontre. NaN signifie que lui ou un objet qui y fait référence ne peut pas être représenté d'une autre manière par javascript. À toutes fins pratiques, il est «inconnu». Étant «inconnu», il ne peut pas vous dire ce qu'il est ni même s'il est lui-même. Ce n'est même pas l'objet auquel il est assigné. Il ne peut que vous dire ce qu'il n'est pas, et le non-né ou le néant ne peut être décrit que mathématiquement dans un langage de programmation. Puisque les mathématiques concernent les nombres, javascript représente le néant sous forme de NaN. Cela ne veut pas dire que ce n'est pas un nombre. Cela signifie que nous ne pouvons pas le lire d'une autre manière qui ait du sens. C'est pourquoi ça peut ' t même égal. Parce que non.

Un meilleur nom pour NaN, décrivant sa signification plus précisément et avec moins de confusion, serait une exception numérique . C'est en réalité un autre type d'objet d'exception déguisé en type primitif (par la conception du langage), où en même temps il n'est pas traité comme primitif dans sa fausse auto-comparaison. D'où la confusion. Et tant que la langue "ne se fera pas la volonté" de choisir entre un objet d'exception approprié et un chiffre primitif , la confusion restera.

La tristement célèbre non-égalité de NaNlui-même, à la fois ==et ===est une manifestation de la conception déroutante forçant cet objet d'exception à être un type primitif. Cela brise le principe fondamental selon lequel une primitive est uniquement déterminée par sa valeur . Si l' NaNon préfère être considéré comme une exception (dont il peut y avoir différents types), alors il ne doit pas être «vendu» comme primitif. Et si on veut qu'il soit primitif, ce principe doit tenir. Tant qu'il est cassé, comme nous l'avons dans JavaScript, et que nous ne pouvons pas vraiment décider entre les deux, la confusion menant à une charge cognitive inutile pour toutes les personnes impliquées restera. Ce qui, cependant, est vraiment facile à corriger en faisant simplement le choix entre les deux:

• soit créer NaNun objet d'exception spécial contenant les informations utiles sur la façon dont l'exception est survenue, au lieu de jeter ces informations comme ce qui est actuellement implémenté, conduisant à un code plus difficile à déboguer;
• ou créer NaNune entité de type primitif number(qui pourrait être moins confuse appelée "numérique"), auquel cas elle devrait être égale à elle-même et ne peut contenir aucune autre information; ce dernier est clairement un choix inférieur.

Le seul avantage concevable de forcer NaNdans le numbertype est de pouvoir le renvoyer dans n'importe quelle expression numérique. Ce qui, cependant, rend le choix fragile, car le résultat de toute expression numérique contenant NaNsera soit NaN, soit conduira à des résultats imprévisibles tels que l' NaN < 0évaluation false, c'est- à -dire le retour booleanau lieu de conserver l'exception.

Et même si «les choses sont telles qu'elles sont», rien ne nous empêche de faire cette distinction claire pour nous-mêmes, pour aider à rendre notre code plus prévisible et plus facile à déboguer. En pratique, cela signifie identifier ces exceptions et les traiter comme des exceptions. Ce qui, malheureusement, signifie plus de code mais, espérons-le, sera atténué par des outils tels que TypeScript de Flowtype.

Et puis nous avons la distinction de signalisationNaN désordonnée calme vs bruyante aka . Ce qui concerne vraiment la façon dont les exceptions sont gérées, pas les exceptions elles-mêmes, et rien de différent des autres exceptions.

De même, Infinityet +Infinitysont des éléments de type numérique apparaissant dans l' extension de la ligne réelle mais ce ne sont pas des nombres réels. Mathématiquement, ils peuvent être représentés par des séquences de nombres réels convergeant vers l'un +ou l' autre -Infinity.

C'est simplement parce que NaNc'est une propriété de l'objet Number dans JS, cela n'a rien à voir avec le fait qu'il s'agit d'un nombre.

La meilleure façon de penser à NAN est que ce n'est pas un nombre connu . C'est pourquoi NAN! = NAN parce que chaque valeur NAN représente un numéro inconnu unique. Les NAN sont nécessaires car les nombres à virgule flottante ont une plage de valeurs limitée. Dans certains cas, l'arrondi se produit lorsque les bits inférieurs sont perdus, ce qui conduit à ce qui semble être un non-sens comme 1.0 / 11 * 11! = 1.0. Les valeurs vraiment grandes qui sont plus grandes sont les NAN, l'infini étant un parfait exemple.

Étant donné que nous n'avons que dix doigts, toute tentative d'afficher des valeurs supérieures à 10 est impossible, ce qui signifie que de telles valeurs doivent être des NAN car nous avons perdu la vraie valeur de cette valeur supérieure à 10. Il en va de même pour les valeurs à virgule flottante, où la valeur dépasse les limites de ce qui peut être contenu dans un flottant.

Parce que NaN est un type de données numérique.

NaNest un nombre du point de vue du type, mais n'est pas un nombre normal comme 1, 2 ou 329131. Le nom "Not A Number" fait référence au fait que la valeur représentée est spéciale et concerne le domaine de spécification du format IEEE, pas domaine de langage javascript.

Si vous utilisez jQuery, je préfère isNumericsur vérifier le type:

console.log($.isNumeric(NaN));  // returns false
console.log($.type(NaN));       // returns number

http://api.jquery.com/jQuery.isNumeric/

Javascript n'a qu'un seul type de données numérique, qui est le flottant standard 64 bits à double précision. Tout est double. NaN est une valeur spéciale de double, mais c'est néanmoins un double.

Tout ce que cela parseIntfait est de «convertir» votre chaîne en un type de données numérique, de sorte que le résultat est toujours «nombre»; seulement si la chaîne d'origine n'était pas analysable, sa valeur sera NaN.

NaN est toujours un type numérique, mais il représente une valeur qui ne peut pas représenter un nombre valide.

Nous pourrions affirmer que NaN est un objet de cas particulier. Dans ce cas, l'objet de NaN représente un nombre qui n'a aucun sens mathématique. Il existe d'autres objets de cas spéciaux en mathématiques comme INFINITE et ainsi de suite.

Vous pouvez toujours faire des calculs avec, mais cela entraînera des comportements étranges.

Plus d'informations ici: http://www.concentric.net/~ttwang/tech/javafloat.htm (basé sur java, pas javascript)

Vous devez aimer Javascript. Il a quelques petites bizarreries intéressantes.

http://wtfjs.com/page/13

La plupart de ces bizarreries peuvent être expliquées si vous vous arrêtez pour les résoudre logiquement, ou si vous connaissez un peu la théorie des nombres, mais elles peuvent néanmoins vous surprendre si vous ne les connaissez pas.

En passant, je recommande de lire le reste de http://wtfjs.com/ - il y a beaucoup plus de bizarreries intéressantes que celle-ci!

La valeur NaN est vraiment le Number.NaN donc quand vous demandez si c'est un nombre, il dira oui. Vous avez fait la bonne chose en utilisant l'appel isNaN ().

Pour information, NaN peut également être retourné par des opérations sur des nombres qui ne sont pas définis comme des divisions par zéro ou la racine carrée d'un nombre négatif.

Un exemple

Imaginez que nous convertissons une chaîne en nombre:

Number("string"); // returns NaN

Nous avons changé le type de données en nombre mais sa valeur n'est pas un nombre!

Il s'agit d'une valeur spéciale de type Number comme POSITIVE_INFINITY

Pourquoi? Intentionnellement