Pourquoi typeof NaN return 'numéro'?

https://stackoverflow.com/questions/2801601

25-09-2019
|

Question

Juste par curiosité.

Il ne semble pas très logique que typeof NaN est le numéro. Tout comme NaN === NaN ou NaN == NaN faux retour, par le chemin. Est-ce l'une des particularités de javascript, ou y aurait-il une raison?

Edit: merci pour vos réponses. Ce n'est pas une chose facile à obtenir les tête autour de bien. La lecture des réponses et le wiki, je compris plus, mais encore, une phrase comme

Une comparaison avec un NaN retourne toujours un résultat même lorsque l'on compare non ordonnée avec elle-même. Les prédicats de comparaison signalent soit ou non-signalisation, les versions de signalisation signalisation d'exception non valide pour de telles comparaisons. Les prédicats d'égalité et d'inégalité sont nonsignaling donc x = x retour faux peut être utilisé pour tester si x est un NaN calme.

juste mon garde tourner la tête. Si quelqu'un peut traduire chez l'homme (par opposition à, disons, mathématicien) langue lisible, je gratefull.

La solution

Il ne signifie pas un numéro. Il n'est pas une particularité du principe de la science informatique, mais javascript commun.

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

Il existe trois types de fonctionnement   qui retour NaN:

Opérations avec un NaN 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 équivalents.


Les 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 n / 2 radians)

Le sinus inverse ou cosinus d'un nombre qui est inférieur à -1 ou   supérieur à +1.

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

Autres conseils

Eh bien, NaN est toujours numérique type , en dépit du fait qu'elle représente réellement non-A-Number: -)

NaN signifie simplement que la valeur spécifique ne peut pas être représentée dans les limites du type numérique (bien que cela puisse dire pour tous les numéros qui doivent être arrondis à adapter, mais NaN est un cas particulier).

est pas considéré comme un NaN spécifique égale à un autre NaN parce qu'ils peuvent être différentes valeurs. Cependant, NaN est encore un type de numéro, tout comme 2718 ou 31415.

Quant à votre question d'expliquer à jour termes simples:

Une comparaison avec un NaN retourne toujours un résultat même lorsque l'on compare non ordonnée avec elle-même. Les prédicats de comparaison signalent soit ou non-signalisation, les versions de signalisation signalisation d'exception non valide pour de telles comparaisons. Les prédicats d'égalité et d'inégalité sont nonsignaling donc x = x retour faux peut être utilisé pour tester si x est un NaN calme.

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

Une comparaison avec un NaN retourne toujours un résultat même lorsque l'on compare non ordonnée avec lui-même.

En fait, un NaN ne correspond pas à un autre numéro, y compris une autre NaN, et même y compris lui-même .

Les prédicats de comparaison signalent soit ou non-signalisation, les versions de signalisation signalisation d'exception non valide pour de telles comparaisons.

Tenter de faire la comparaison (moins, plus que, et ainsi de suite) opérations entre un NaN et un autre numéro peut soit donner lieu à une exception jetée (signalisation) ou tout simplement obtenir de faux que le résultat (non-signalisation ou calme) .

Les prédicats d'égalité et d'inégalité sont nonsignaling donc x = x retour faux peut être utilisé pour tester si x est un NaN calme.

Tests pour l'égalité (égal, pas égal à) signalent jamais si leur utilisation ne provoque pas une exception. Si vous avez un nombre régulier x, puis x == x sera toujours vrai. Si x est un NaN, alors x == x sera toujours faux. Il te donne un moyen de détecter NaN facilement (tranquillement).

La norme ECMAScript (JavaScript) précise que Numbers sont IEEE 754 flotte, qui comprennent NaN comme une valeur possible.

ECMA 262 Section 5e 4.3.19 : Valeur Nombre

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

ECMA 262 Section 5e 4.3.23 : NaN

valeur numérique qui est un IEEE 754 valeur "Not-a-Number".

IEEE 754 sur Wikipedia

La norme IEEE Arithmétique à 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 à virgule flottante [...]

Les définit standard


formats arithmétiques : ensembles de données à virgule flottante binaire et décimal, qui consistent en des nombres finis (y compris signés zéros et les numéros subnormales), infinités et valeurs « pas un numéro » spécial (NaN)


[...]

retourne typeof NaN 'number' parce que:

spécification ECMAScript dit le type de numéro comprend NaN:


de type 4.3.20 Numéro

ensemble de toutes les valeurs possibles, y compris le numéro « Not-a-Number » spécial   valeurs (NAN), l'infini positif, et l'infini négatif

renvoie donc typeof en conséquence:

11.4.3 L'opérateur typeof

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

Soit val être le résultat de l'évaluation UnaryExpression .
Si type ( val ) est < a href = "http://www.ecma-international.org/ecma-262/5.1/#sec-8.7"> de référence,
1. Si IsUnresolvableReference ( val ) est < strong> true , "undefined" de retour.
2. Soit val GetValue ( val ).
Retourne une chaîne déterminée par le type de ( val ) conformément au 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 Arithmétique flottante (IEEE 754) :

4.3.19 Valeur Nombre

valeur primitive correspondant à une double précision binaire de 64 bits   Format valeur IEEE 754

4.3.23 NaN

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

8.5 Le type Numéro

Le type de numéro a exactement 18437736874454810627 (à savoir, 2 ⁵³ -2 ⁶⁴ 3)   valeurs, représentant le double précision le format 64 bits IEEE 754   les valeurs spécifiées dans la norme IEEE pour binaire à virgule flottante   Arithmétique, sauf que la 9007199254740990 (soit 2 ⁵³ -2) distincte   « Not-a-Number » valeurs de la norme IEEE sont représentés dans   ECMAScript comme une seule spéciale NaN valeur. (Notez que le NaN valeur   est produite par l'expression d'NaN du programme.)

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

et NaN === NaN est faux, car ils ne sont pas nécessairement les mêmes non-nombre

NaN != NaN parce qu'ils ne sont pas nécessairement les mêmes non-nombre. Ainsi, il fait beaucoup de sens ... Aussi pourquoi flotteurs ont à la fois et +0.00 -0.00 qui ne sont pas les mêmes. Arrondi peut le faire, ils sont en fait pas nul.

En ce qui concerne typeof, cela dépend de la langue. Et la plupart des langues diront que NaN est un flotteur, double ou nombre en fonction de la façon dont ils classent ... Je ne connais pas les langues qui diront que c'est un type inconnu ou nulle.

NaN signifie Pas un numéro . Il est une valeur de types de données numériques (flottantes généralement les types de points, mais pas toujours) qui représente le résultat d'une opération non valide comme la division par zéro.

Bien que ses noms dit que ce n'est pas un numéro, le type de données utilisé pour le maintenir est un type numérique. Donc, en JavaScript, demandant le type de données NaN retournera number (comme alert(typeof(NaN)) démontre clairement).

Javascript utilise NaN pour représenter tout ce qu'il rencontre qui ne peut être représenté d'une autre manière par ses spécifications. Cela ne signifie pas qu'il est pas un numéro. Il est juste la meilleure façon de décrire la rencontre. NaN signifie que le ou un objet qui se réfère à elle ne peut pas être représenté d'une autre manière par javascript. Pour toutes fins pratiques, il est « inconnu ». « Inconnu », il ne peut pas vous dire ce qu'il est, ni même si elle est elle-même. Il est même pas l'objet auquel il est affecté. Il ne peut vous dire ce que ce n'est pas, et non-ness ou le néant ne peut être décrite mathématiquement dans un langage de programmation. Étant donné que les mathématiques sont sur les chiffres, javascript représente le néant comme NaN. Cela ne signifie pas qu'il est pas un numéro. Cela signifie que nous ne pouvons pas lire toute autre façon logique. Voilà pourquoi il ne peut même pas lui-même égal. Parce qu'il ne fonctionne pas.

Un meilleur nom pour NaN, décrivant sa signification plus précise et moins confusément, serait une exception numérique . Il est vraiment un autre type d'objet d'exception déguisé en ayant le type primitif (par la conception de la langue), où même il n'est pas traitée comme primitive dans son faux autocomparaison. D'où la confusion. Et aussi longtemps que la langue « ne fera pas son esprit » de choisir entre bon objet exception et chiffre primitif , la confusion reste.

Le tristement célèbre non-égalité de NaN à lui-même, à la fois == et === est une manifestation de la conception confusion forçant cet objet d'exception en étant un type primitif. Cela rompt le principe fondamental selon lequel un primitive est déterminé de manière unique par sa valeur . Si NaN est préférable d'être considéré comme exception (dont il peut y avoir différents types), alors il ne doit pas être « vendu » comme primitive. Et si on voulait être primitif, ce principe doit tenir. Tant qu'il est cassé, que nous avons en JavaScript, et nous ne pouvons pas vraiment choisir entre les deux, la confusion qui conduit à la charge cognitive nécessaire pour tout le monde restera. Ce qui, cependant, est vraiment facile à corriger en faisant simplement le choix entre les deux:

soit faire NaN un objet d'exception spéciale contenant les informations utiles sur la façon dont l'exception se pose, par opposition à jeter cette information loin que ce qui est actuellement mis en œuvre, ce qui conduit à un code plus difficile à debug;
ou faire NaN une entité du type primitif number (qui pourrait être moins confusément appelé « numérique »), auquel cas il devrait être égal à lui-même et ne peut pas contenir toute autre information; ce dernier est clairement un choix inférieur.

L'avantage concevable de forcer NaN dans le type de number est d'être capable de le jeter de nouveau dans une expression numérique. Ce qui, cependant, rend le choix fragile, parce que le résultat d'une expression numérique contenant NaN sera soit NaN ou conduisant à des résultats imprévisibles, tels que l'évaluation NaN < 0 à false, à savoir le retour boolean au lieu de garder l'exception.

Et même si « les choses sont comme 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 easierly débogable. Dans la pratique, cela signifie identifier les exceptions et les traiter comme des exceptions. Ce qui, malheureusement, signifie plus de code, mais nous l'espérons, être atténués par des outils tels que tapuscrit de Flowtype.

Et puis nous avons les href="https://en.wikipedia.org/wiki/NaN" désordre calme vs distinction NaN bruyante signalisation aka . Ce qui est vraiment sur la façon dont les exceptions sont gérées, et non les exceptions elles-mêmes, et rien d'autre des autres exceptions.

De même, Infinity et +Infinity sont des éléments de type numérique survenant dans le poste de l' mais ils ne sont pas des nombres réels. Mathématiquement, ils peuvent être représentés par des séquences de nombres réels qui convergent l'une + ou -Infinity.

Ceci est tout simplement parce que NaN est une propriété de l'objet Nombre de JS, il n'a rien à voir avec elle étant un nombre.

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

Étant donné que nous n'avons dix doigts toute tentative de montrer des valeurs supérieures à 10 sont impossibles, ce qui signifie que ces valeurs doivent être Nans parce que nous avons perdu la valeur réelle de cette supérieure à 10 valeur. La même chose est vraie des valeurs à virgule flottante, dont la valeur dépasse les limites de ce qui peut se tenir dans un flotteur.

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

NaN est un numéro d'un point de vue du type, mais 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écial et est sur le domaine des spécifications du format IEEE, pas dans le domaine du langage javascript.

Si vous utilisez jQuery, je préfère isNumeric sur la vérification du type:

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

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

Javascript ne possède qu'un seul type de données numérique, qui est la norme flottante double précision 64 bits. Tout est double. NaN est une valeur spéciale double, mais il est néanmoins un double.

Tout ce parseInt fait est de « jeter » votre chaîne en un type de données numériques, de sorte que le résultat est toujours « numéro »; que si la chaîne d'origine n'a pas été analysable, sa valeur sera NaN.

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

Nous pourrions soutenir que NaN est un objet de cas particulier. Dans ce cas, l'objet de NaN représente un nombre qui n'a pas de sens mathématique. Il y a un autre cas particulier des objets en mathématiques comme INFINITE et ainsi de suite.

Vous pouvez toujours faire des calculs avec elle, mais qui donnera des comportements étranges.

Plus d'infos ici: http://www.concentric.net/~ttwang/ Tech / javafloat.htm (java base, pas javascript)

Vous devez aimer Javascript. Il a quelques petites bizarreries.

http://wtfjs.com/page/13

La plupart de ces bizarreries peut être expliqué si vous arrêtez de les travailler logiquement, ou si vous connaissez un peu la théorie des nombres, mais néanmoins ils peuvent encore vous surprendre si vous ne savez pas sur eux.

Par ailleurs, je vous recommande de lire le reste de http://wtfjs.com/ - il y a beaucoup bizarreries plus intéressants que celui-ci à trouver!

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

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

Un exemple

Nous convertissons Imaginer une chaîne en nombre:

Number("string"); // returns NaN

Nous avons changé le type de données à numéro, mais sa valeur est pas un nombre!

Il est valeur particulière du type de numéro comme POSITIVE_INFINITY

Pourquoi? De par sa conception

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow