Warum gibt typeof NaN „Nummer“ zurück?

https://stackoverflow.com/questions/2801601

25-09-2019
|

Frage

Nur aus Neugier.

Das scheint nicht sehr logisch zu sein typeof NaN ist Nummer.So wie NaN === NaN oder NaN == NaN gibt übrigens false zurück.Ist das eine der Besonderheiten von Javascript, oder gibt es dafür einen Grund?

Bearbeiten:Danke für deine Antworten.Allerdings ist es nicht einfach, sich zurechtzufinden.Als ich die Antworten und das Wiki las, verstand ich mehr, aber dennoch einen Satz wie

Ein Vergleich mit einem NaN liefert immer ein ungeordnetes Ergebnis, auch wenn er mit sich selbst verglichen wird.Die Vergleichsprädikate sind entweder signalisierend oder nicht signalisierend, die Signalisierungsversionen signalisieren eine ungültige Ausnahme für solche Vergleiche.Die Gleichheits- und Ungleichheitsprädikate sind nicht signalisierend, daher kann x = x, das „false“ zurückgibt, verwendet werden, um zu testen, ob x ein stilles NaN ist.

Mir dreht sich einfach der Kopf.Wenn jemand dies in eine für Menschen (im Gegensatz zu beispielsweise einer Mathematikersprache) lesbare Sprache übersetzen kann, wäre ich dankbar.

Lösung

Es bedeutet keine Zahl. Es ist keine Besonderheit von JavaScript, aber gemeinsamem Informatik-Prinzip.

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

Es gibt drei Arten von Betrieb   die Rückkehr NaN:

Operationen mit NaN als mindestens einen Operanden

Unbestimmte Formen


Die Divisionen 0/0, ∞ / ∞, ∞ / -∞, -∞ / ∞ und -∞ / -∞

Die Multiplikationen 0 × ∞ und 0 × -∞

Die Leistung 1 ^ ∞

Die Zugänge ∞ + (-∞), (-∞) + ∞ und äquivalente Subtraktionen.


Echt Operationen mit komplexen Ergebnisse:


Die Quadratwurzel aus einer negativen Zahl

Der Logarithmus einer negativen Zahl

Der Tangens eines ungeraden Vielfachen von 90 Grad (oder π / 2 Radiant)

Die inverse Sinus- oder Cosinus einer Zahl, die kleiner ist als -1 oder   größer als +1.

All diese Werte können nicht gleich sein. Ein einfacher Test für eine NaN ist, um Test value == value falsch ist.

Andere Tipps

Nun, NaN ist immer noch ein numerische Typ , trotz der Tatsache, es steht tatsächlich für Nicht-A-Nummer: -)

NaN nur bedeutet, dass der spezifische Wert nicht innerhalb der Grenzen des numerischen Typs dargestellt werden (obwohl das für alle Zahlen gesagt werden könnte, die fit abgerundet sein müssen, aber NaN ist ein Sonderfall).

Ein spezifischer NaN wird an einem anderen NaN nicht als gleich betrachtet, da sie unterschiedliche Werte sein können. Allerdings NaN ist noch eine Reihe Art, wie 2718 oder 31415.

In Bezug auf die aktualisierte Frage in juristischer Hinsicht zu erklären:

Ein Vergleich mit NaN gibt immer ein ungeordnetes Ergebnis selbst wenn sie mit mir selbst verglichen wird. Die Vergleichsprädikate sind entweder Signalisierung oder nicht-Signalisierung, die Signalisierungs Versionen signalisieren eine ungültige Ausnahme für solche Vergleiche. Die Gleichheit und Ungleichheit Prädikate werden nicht-Signalisierung so x = x falsch Rückkehr kann Test verwendet werden, wenn x eine ruhige NaN ist.

All diese Mittel (unterteilt in Teile):

Ein Vergleich mit NaN liefert immer ein ungeordnetes Ergebnis selbst wenn sie mit mir selbst verglichen wird.

Grundsätzlich ist ein NaN gleich keine andere Zahl, einschließlich einem anderen NaN und sogar einschließlich selbst .

Die Vergleichsprädikate entweder signalisieren oder nicht-Signalisierung, die Signalisierungs Versionen signalisieren eine ungültige Ausnahme für solche Vergleiche.

Der Versuch Vergleich zu tun (kleiner als, größer als, und so weiter) Operationen zwischen einem NaN und einem anderen Nummer kann entweder zu einer Ausnahme geworfen (Signalisierung) oder einfach nur falsch bekommen als das Ergebnis (Non-Signaling oder ruhig) .

Die Gleichheit und Ungleichheit Prädikate werden nicht-Signalisierung so x = x falsch Rückkehr kann Test verwendet werden, wenn x eine ruhige NaN ist.

Tests auf Gleichheit (gleich, gleich nicht) nie signalisieren sie so verwendet, wird nicht Ursache einer Ausnahme. Wenn Sie eine reguläre Nummer x haben, dann werden x == x immer wahr sein. Wenn x ein NaN ist, dann wird x == x immer falsch sein. Es wird Ihnen eine Möglichkeit geben NaN leicht zu erkennen (leise).

Der ECMAScript (JavaScript) Standard spezifiziert, dass Numbers sind IEEE 754 Schwimmern, die NaN enthalten, wie ein möglicher Wert.

ECMA 262 5e Abschnitt 4.3.19 : Anzahl Wert

primitiver Wert mit doppelter Genauigkeit entsprechenden 64-Bit-Binär-Format IEEE 754-Wert.

ECMA 262 5e Abschnitt 4.3.23 : NaN

Zahlenwert, ist ein IEEE 754 "Not-a-Number" Wert.

IEEE 754 auf Wikipedia

Der IEEE-Standard für Gleitkomma-Arithmetik ist ein technischer durch das Institute of Electrical etablierten Standard and Electronics Engineers und der am weitesten verbreiteten Standard für Fließkommaberechnung [...]

Der Standard definiert


arithmetische Formate : Sätze von binären und dezimalen Gleitkommadaten, die aus endlichen Zahlen bestehen (einschließlich signierten Nullen und subnormale Zahlen), infinities und special „keine Zahl“ -Werten (NaN)


[...]

typeof NaN kehrt 'number' weil:

ECMAScript-Spezifikation sagt die Anzahl Typ NaN enthält:


4.3.20 Zahl type

Menge aller möglichen Zahlenwerte einschließlich der speziellen „Not-a-Number“   (NaN) Werte, positive Unendlichkeit und negative Unendlichkeit

So typeof kehrt entsprechend:

11.4.3 Der typeof Operator

Die Produktion UnaryExpression : typeof UnaryExpression ist wie folgt bewertet:

Let val das Ergebnis der Auswertung UnaryExpression .
Wenn Typ ( val ) ist < a href = "http://www.ecma-international.org/ecma-262/5.1/#sec-8.7"> Reference, dann
1. Wenn IsUnresolvableReference ( val ) ist < strong> true , Rückkehr "undefined".
2. Lassen Sie val GetValue ( val ).
Zurück a String bestimmt von Typ ( val ) gemäß Tabelle 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".            |
------------------------------------------------------------------

Dieses Verhalten ist in Übereinstimmung mit IEEE-Standard für Gleitkomma-Arithmetik (IEEE 754) :

4.3.19 Zahlenwert

entsprechenden Grundwert auf einen Double-Precision-64-Bit-Binär   Format IEEE 754-Wert

4.3.23 NaN

Zahlenwert, der ein IEEE 754 „Not-a-Number“ Wert
ist
8.5 Die Anzahl Typ

der Nummerntyp hat genau 18437736874454810627 (das heißt, 2 ⁵³ -2 ⁶⁴ +3)   Werte, die mit doppelter Genauigkeit 64-Bit-Format IEEE 754 darstellen   Werte wie für binäre Gleitkommaarithmetik in dem IEEE-Standard spezifizierte   Arithmetik, mit der Ausnahme, dass die 9007199254740990 (dh 2 ⁵³ -2) deutlichen   „Not-a-Number“ Werte des IEEE-Standard sind vertreten in   ECMAScript als eine einzige spezielle NaN Wert. (Beachten Sie, dass die NaN Wert   durch das Programm Ausdruck NaN erzeugt wird.)

NaN ist ein gültiger Gleitkommawert ( http://en.wikipedia.org/wiki/NaN )

und NaN === NaN ist falsch, weil sie nicht notwendigerweise die gleiche nicht-Zahl

sind

NaN != NaN, weil sie nicht notwendig, die gleiche nicht-Nummer sind. So macht es sehr viel Sinn ... Auch warum Schwimmer haben beide +0,00 und -0,00, die nicht gleich sind. Abrunden kann tun, dass sie eigentlich nicht gleich Null sind.

Wie bei typeof, die auf der Sprache abhängt. Und die meisten Sprachen werden sagen, dass NaN ein Schwimmer ist, Doppel- oder Anzahl je nachdem, wie sie es klassifizieren ... ich keine Sprachen kennen, werden sagen, dies ist ein unbekannter Typ oder null.

NaN steht für keine Zahl . Es ist ein Wert von numerischen Datentypen (in der Regel Punkttypen schwimmen, aber nicht immer), die das Ergebnis einer ungültigen Operation wie Division durch Null darstellt.

Obwohl die Namen sagen, dass es keine Zahl, der Datentyp verwendet halten es ein numerischer Typ ist. So in JavaScript für den Datentyp NaN fragen wird number zurückkehren (wie alert(typeof(NaN)) zeigt deutlich).

uses Javascript NaN alles darzustellen, trifft es das kann nicht auf andere Weise durch seine Spezifikationen dargestellt werden. Es bedeutet nicht, es ist keine Zahl. Es ist nur der einfachste Weg, die Begegnung zu beschreiben. NaN bedeutet, dass er oder ein Objekt, das auf sie Bezug nimmt auf keine andere Art und Weise durch Javascript, dargestellt werden könnte. Für alle praktischen Zwecke ist es ‚unbekannt‘. Als ‚unbekannt‘ es kann Ihnen nicht sagen, was es ist ja nicht einmal, wenn sie selbst ist. Es ist nicht einmal das Objekt, um es zugeordnet ist. Es kann Ihnen nur sagen, was es nicht ist, und nicht-ness oder Nichts kann nur mathematisch in einer Programmiersprache beschrieben. Da die Mathematik über Zahlen ist, stellt Javascript Nichts als NaN. Das bedeutet nicht, es ist keine Zahl. Es bedeutet, dass wir es auf andere Weise nicht lesen können, die Sinn macht. Deshalb ist es nicht einmal selbst gleich. Weil es nicht.

Ein besserer Name für NaN, um seine Bedeutung genauer und weniger verwirrend zu beschreiben, wäre a numerische Ausnahme.Es handelt sich in Wirklichkeit um eine andere Art von Ausnahmeobjekt, das (durch das Sprachdesign) als primitiv getarnt wird, wobei es gleichzeitig in seinem falschen Selbstvergleich nicht als primitiv behandelt wird.Daher die Verwirrung.Und solange die Sprache „sich nicht entschließen kann“, zwischen ihnen zu wählen richtiges Ausnahmeobjekt Und primitive Zahl, die Verwirrung wird bleiben.

Die berüchtigte Ungleichheit von NaN für sich selbst, beides == Und === ist eine Manifestation des verwirrenden Designs, das dieses Ausnahmeobjekt dazu zwingt, ein primitiver Typ zu sein.Dies verstößt gegen das Grundprinzip, dass a Primitiv wird eindeutig durch seinen Wert bestimmt.Wenn NaN wird lieber als Ausnahme betrachtet (von der es verschiedene Arten geben kann), dann sollte es nicht als primitiv „verkauft“ werden.Und wenn es primitiv sein soll, muss dieses Prinzip gelten.Solange es kaputt ist, wie bei JavaScript, und wir uns nicht wirklich zwischen den beiden entscheiden können, bleibt die Verwirrung bestehen, die zu einer unnötigen kognitiven Belastung für alle Beteiligten führt.Was sich jedoch wirklich leicht beheben lässt, indem man einfach die Wahl zwischen den beiden trifft:

entweder machen NaN ein spezielles Ausnahmeobjekt, das nützliche Informationen darüber enthält, wie die Ausnahme entstanden ist, anstatt diese Informationen als aktuell implementierte Informationen wegzuwerfen, was zu schwieriger zu debuggendem Code führt;
oder machen NaN eine Entität vom primitiven Typ number (das könnte weniger verwirrend als „numerisch“ bezeichnet werden). In diesem Fall sollte es sich selbst entsprechen und keine anderen Informationen enthalten;Letzteres ist eindeutig eine minderwertige Wahl.

Der einzig denkbare Vorteil des Forcierens NaN hinein number Typ besteht darin, es in einen beliebigen numerischen Ausdruck zurückwerfen zu können.Dies macht es jedoch zu einer spröden Wahl, da das Ergebnis jeden numerischen Ausdruck enthält NaN wird entweder sein NaN, oder zu unvorhersehbaren Ergebnissen führen, z NaN < 0 bewertend zu false, d.h.zurückkehren boolean anstatt die Ausnahme beizubehalten.

Und selbst wenn „die Dinge so sind, wie sie sind“, hindert uns nichts daran, diese klare Unterscheidung für uns selbst zu treffen, um unseren Code vorhersehbarer und leichter debuggbar zu machen.In der Praxis bedeutet das, diese Ausnahmen zu identifizieren und sie als Ausnahmen zu behandeln.Das bedeutet leider mehr Code, wird aber hoffentlich durch Tools wie TypeScript von Flowtype abgemildert.

Und dann haben wir das Durcheinander leise vs. laut, auch Signalisierung genannt NaN Unterscheidung.Dabei geht es wirklich darum, wie Ausnahmen behandelt werden, nicht um die Ausnahmen selbst und um nichts, was sich von anderen Ausnahmen unterscheidet.

Ähnlich, Infinity Und +Infinity sind Elemente von numerischer Typ entstehend in der Verlängerung der realen Linie aber es sind keine reellen Zahlen.Mathematisch können sie durch Folgen reeller Zahlen dargestellt werden, die gegen beide konvergieren + oder -Infinity.

Das ist einfach weil NaN eine Eigenschaft des Number-Objekts in JS ist, hat nichts zu tun hat mit ihm eine Nummer zu sein.

Der beste Weg, NAN zu denken ist, dass sie nicht ein bekannt Nummer. Das ist, warum NAN! = NAN weil jeder NAN-Wert einige einzigartige unbekannte Zahl darstellt. Nans sind notwendig, da Gleitkommazahlen eine begrenzte Anzahl von Werten aufweisen. In einigen Fällen Rundung auftritt, wo die unteren Bits, das führt zu verloren gehen, was scheint Unsinn wie 1,0 / 11 * 11 zu sein! = 1,0. Wirklich große Werte, die größer sind Nans mit unendlich ein perfektes Beispiel.

Da wir nur zehn Finger haben jeden Versuch, Werte zu zeigen, mehr als 10 nicht möglich sind, die solche Werte bedeutet Nans sein muss, weil wir den wahren Wert dieser größer als 10 Wert verloren haben. Das gleiche gilt für Fließkommawerte, wobei der Wert der Grenzen des überschreitet in einem Schwimmer gehalten werden.

Da NaN ist ein numerischer Datentyp.

NaN eine Zahl von einem Typ Sicht ist aber nicht eine normale Zahl wie 1, 2 oder 329131. Der Name „nicht eine Zahl“ bezieht sich auf die Tatsache, dass der Wert repräsentierte und speziell ist über das Domain-Spezifikation IEEE-Format, keine Javascript Sprachdomäne.

Bei der Verwendung von jQuery, ziehe ich isNumeric über die Art Überprüfung:

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

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

Javascript hat nur einen numerischen Datentyp, der die Standard-64-Bit-Double-Precision-Schwimmer ist. Alles ist eine doppelte. NaN ist ein spezieller Wert des Doppels, aber es ist ein doppelter dennoch.

Alles, was parseInt tut, ist zu „cast“ Zeichenfolge in einen numerischen Datentyp, so ist das Ergebnis immer „Nummer“; nur dann, wenn die ursprüngliche Zeichenfolge nicht parseable ist, wird sein Wert NaN sein.

NaN ist immer noch ein numerischer Typ, aber es stellt Wert, der keine gültige Zahl darstellen.

Wir könnten argumentieren, dass NaN ist ein Sonderfall Objekt. In diesem Fall stellt NaN Objekt eine Zahl, die keinen mathematischen Sinn macht. Es gibt einige andere Sonderfall Objekte in Mathe wie Unendlichen und so weiter.

Sie können noch einige Berechnungen mit ihm tun, aber das wird seltsames Verhalten ergeben.

Weitere Informationen hier: http://www.concentric.net/~ttwang/ tech / javafloat.htm (Java-basierte, kein Javascript)

Sie haben Javascript zu lieben. Es hat einige interessante kleine Macken.

http://wtfjs.com/page/13

Die meisten dieser Macken erklärt werden kann, wenn man sie logisch aufhören zu arbeiten, oder wenn Sie ein wenig über Zahlentheorie wissen, aber dennoch können sie Ihnen noch heraus fangen, wenn man über sie nicht kennen.

Übrigens empfehle ich den Rest Lesen von http://wtfjs.com/ - es gibt viel, interessante Macken als diese zu finden sind!

Der Wert NaN ist wirklich die Number.NaN daher, wenn Sie fragen, ob es sich um eine Zahl ist, wird es ja sagen. Sie haben das Richtige durch die isNaN () -Aufruf verwenden.

Weitere Informationen NaN kann auch durch Operationen auf Zahlen zurückgeführt werden, die wie Divisionen definiert sind, nicht durch Null oder Quadratwurzel aus einer negativen Zahl.

Ein Beispiel

Stellen Sie sich vor Wir sind eine Zeichenfolge in eine Zahl konvertieren:

Number("string"); // returns NaN

Wir änderten den Datentyp Zahl, aber sein Wert ist nicht eine Zahl!

Es ist besonderer Wert des Zahlentypen als POSITIVE_INFINITY

Warum? Mit dem Design

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow