Warum gibt der NaN-Typ "Nummer" zurück?

Nur aus Neugier.

Es scheint nicht sehr logisch, dass dies typeof NaNeine Zahl ist. Übrigens genau wie NaN === NaNoder NaN == NaNfalsch zurückgegeben. Ist dies eine der Besonderheiten von Javascript oder gibt es einen Grund dafür?

Edit: danke für deine antworten. Es ist jedoch nicht einfach, sich zurechtzufinden. Antworten lesen und das Wiki habe ich besser verstanden, aber trotzdem einen Satz wie

Ein Vergleich mit einem NaN liefert auch beim Vergleich mit sich selbst immer ein ungeordnetes Ergebnis. 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, sodass x = x, das false zurückgibt, verwendet werden kann, um zu testen, ob x ein ruhiges NaN ist.

hält nur meinen Kopf in Bewegung. Wenn jemand dies in eine lesbare Sprache übersetzen kann (im Gegensatz beispielsweise zu einem Mathematiker), wäre ich dankbar.

Es bedeutet keine Zahl. Es ist keine Besonderheit von Javascript, sondern ein allgemeines Informatikprinzip.

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

Es gibt drei Arten von Operationen, die NaN zurückgeben:

Operationen mit einem NaN als mindestens einem Operanden

Unbestimmte Formen

• Die Unterteilungen 0/0, ∞ / ∞, ∞ / −∞, −∞ / ∞ und −∞ / −∞
• Die Multiplikationen 0 × ∞ und 0 × −∞
• Die Kraft 1 ^ ∞
• Die Additionen ∞ + (−∞), (−∞) + ∞ und äquivalente Subtraktionen.

Reale Operationen mit komplexen Ergebnissen:

• Die Quadratwurzel einer negativen Zahl
• Der Logarithmus einer negativen Zahl
• Die Tangente eines ungeraden Vielfachen von 90 Grad (oder π / 2 Bogenmaß)
• Der inverse Sinus oder Cosinus einer Zahl, die kleiner als -1 oder größer als +1 ist.

Alle diese Werte sind möglicherweise nicht gleich. Ein einfacher Test für ein NaN ist zu testen, value == valueist falsch.

Nun, NaNist immer noch ein numerischer Typ , obwohl er eigentlich für Not-A-Number steht :-)

NaNbedeutet nur, dass der spezifische Wert nicht innerhalb der Grenzen des numerischen Typs dargestellt werden kann (obwohl dies für alle Zahlen gesagt werden könnte, die gerundet werden müssen, um zu passen, ist aber NaNein Sonderfall).

Ein bestimmter Wert NaNwird nicht als gleichwertig angesehen, NaNda es sich möglicherweise um unterschiedliche Werte handelt. Es handelt sich jedoch NaNimmer noch um einen Zahlentyp, genau wie bei 2718 oder 31415.

Zu Ihrer aktualisierten Frage, die in Laienbegriffen zu erklären ist:

Ein Vergleich mit einem NaN liefert auch beim Vergleich mit sich selbst immer ein ungeordnetes Ergebnis. Die Vergleichsprädikate sind entweder signalisierend oder nicht signalisierend, die Signalisierungsversionen signalisieren eine ungültige Ausnahme für solche Vergleiche. Die Prädikate für Gleichheit und Ungleichheit sind nicht signalisierend, sodass x = x, das false zurückgibt, verwendet werden kann, um zu testen, ob x ein ruhiges NaN ist.

Alles was dies bedeutet ist (in Teile zerlegt):

Ein Vergleich mit einem NaN liefert auch beim Vergleich mit sich selbst immer ein ungeordnetes Ergebnis.

Grundsätzlich ist a NaNnicht gleich einer anderen Zahl, einschließlich einer anderen NaNund sogar einschließlich sich selbst .

Die Vergleichsprädikate sind entweder signalisierend oder nicht signalisierend, die Signalisierungsversionen signalisieren eine ungültige Ausnahme für solche Vergleiche.

Der Versuch, Vergleichsoperationen (kleiner als, größer als usw.) zwischen einer NaNund einer anderen Zahl durchzuführen, kann entweder dazu führen, dass eine Ausnahme ausgelöst wird (Signalisierung) oder als Ergebnis nur falsch wird (Nicht-Signalisierung oder leise).

Die Prädikate für Gleichheit und Ungleichheit sind nicht signalisierend, sodass x = x, das false zurückgibt, verwendet werden kann, um zu testen, ob x ein ruhiges NaN ist.

Tests auf Gleichheit (gleich, nicht gleich) signalisieren niemals, so dass ihre Verwendung keine Ausnahme verursacht. Wenn Sie eine reguläre Nummer haben x, ist dies x == ximmer der Fall. Wenn a xist NaN, dann ist x == xes immer falsch. Es gibt Ihnen eine Möglichkeit, NaNleicht (leise) zu erkennen .

Der ECMAScript (JavaScript) -Standard gibt an, dass Numberses sich um IEEE 754- Floats handelt, die NaNeinen möglichen Wert enthalten.

ECMA 262 5e Abschnitt 4.3.19 : Zahlenwert

primitiver Wert, der einem IEEE 754-Wert im 64-Bit-Binärformat mit doppelter Genauigkeit entspricht.

ECMA 262 5e Abschnitt 4.3.23 : NaN

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

IEEE 754 auf Wikipedia

Der IEEE-Standard für Gleitkomma-Arithmetik ist ein vom Institut für Elektrotechnik- und Elektronikingenieure festgelegter technischer Standard und der am weitesten verbreitete Standard für Gleitkomma-Berechnungen [...]

Der Standard definiert

• arithmetische Formate : Sätze von binären und dezimalen Gleitkommadaten, die aus endlichen Zahlen (einschließlich vorzeichenbehafteter Nullen und subnormalen Zahlen), Unendlichkeiten und speziellen "Nicht-Zahlen" -Werten (NaNs) bestehen.

[...]

typeof NaNgibt zurück, 'number'weil:

• Laut ECMAScript-Spezifikation enthält der Nummerntyp NaN:

  4.3.20 Nummerntyp

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

• Also typeofkehrt entsprechend zurück:

  11.4.3 Der Typ des Bedieners

  Die Produktion UnaryExpression : typeof UnaryExpression wird wie folgt ausgewertet:

  1. Sei val das Ergebnis der Auswertung von UnaryExpression .
  2. Wenn Typ ( Wert ) Referenz ist , dann
     1. Wenn IsUnresolvableReference ( val ) true ist , geben Sie return zurück "undefined".
     2. Lassen Val sein GetValue ( val ).
  3. Gibt einen String zurück , bestimmt durch 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 entspricht dem IEEE-Standard für Gleitkomma-Arithmetik (IEEE 754) :

4.3.19 Zahlenwert

primitiver Wert, der einem IEEE 754-Wert im 64-Bit-Binärformat mit doppelter Genauigkeit entspricht

4.3.23 NaN

Zahlenwert, der ein IEEE 754-Wert „Not-a-Number“ ist

8.5 Der Nummerntyp

Der Zahlentyp hat genau 18437736874454810627 (dh 2 ⁵³ −2 ⁶⁴ +3) Werte, die die im IEEE-Standard für binäre Gleitkomma-Arithmetik angegebenen IEEE 754-Werte im 64-Bit-Format mit doppelter Genauigkeit darstellen, mit Ausnahme der Werte 9007199254740990 ( Das heißt, 2 ⁵³ −2) unterschiedliche „Not-a-Number“ -Werte des IEEE-Standards werden in ECMAScript als ein einziger spezieller NaN- Wert dargestellt. (Beachten Sie, dass der NaN- Wert vom Programmausdruck erzeugt wird NaN.)

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

und NaN === NaN ist falsch, weil sie nicht unbedingt dieselbe Nichtzahl sind

NaN != NaNweil sie nicht notwendig sind, die gleiche Nicht-Nummer. Daher macht es sehr viel Sinn ... Auch warum Floats sowohl +0.00 als auch -0.00 haben, die nicht gleich sind. Rundungen können dazu führen, dass sie tatsächlich nicht Null sind.

Der Typ hängt von der Sprache ab. Und die meisten Sprachen werden sagen, dass NaN ein Float, Double oder Number ist, je nachdem, wie sie es klassifizieren ... Ich kenne keine Sprachen, die sagen, dass dies ein unbekannter Typ oder Null ist.

NaNsteht für Not a Number . Es ist ein Wert von numerischen Datentypen (normalerweise Gleitkommatypen, aber nicht immer), der das Ergebnis einer ungültigen Operation wie dem Teilen durch Null darstellt.

Obwohl der Name besagt, dass es sich nicht um eine Zahl handelt, handelt es sich bei dem Datentyp, der verwendet wird, um einen numerischen Typ. Wenn Sie in JavaScript nach dem Datentyp von fragen, NaNwird dies zurückgegeben number(wie alert(typeof(NaN))deutlich gezeigt wird).

Javascript verwendet NaN, um alles darzustellen, auf das es stößt, und das durch seine Spezifikationen nicht anders dargestellt werden kann. Es bedeutet nicht, dass es keine Zahl ist. Es ist nur der einfachste Weg, die Begegnung zu beschreiben. NaN bedeutet, dass es oder ein Objekt, das sich darauf bezieht, nicht anders durch Javascript dargestellt werden kann. Für alle praktischen Zwecke ist es "unbekannt". Da es "unbekannt" ist, kann es Ihnen weder sagen, was es ist, noch ob es selbst ist. Es ist nicht einmal das Objekt, dem es zugewiesen ist. Es kann Ihnen nur sagen, was es nicht ist, und Nichts oder Nichts kann nur mathematisch in einer Programmiersprache beschrieben werden. Da es in der Mathematik um Zahlen geht, repräsentiert Javascript das Nichts als NaN. Das heißt nicht, dass es keine Zahl ist. Es bedeutet, dass wir es nicht anders lesen können, was Sinn macht. Deshalb kann es ' t gleich sich selbst gleich. Weil es nicht so ist.

Ein besserer Name für NaNeine genauere und weniger verwirrende Beschreibung seiner Bedeutung wäre eine numerische Ausnahme . Es ist wirklich eine andere Art von Ausnahmeobjekt, das als primitiver Typ getarnt ist (durch das Sprachdesign), wobei es gleichzeitig in seinem falschen Selbstvergleich nicht als primitiv behandelt wird. Woher die Verwirrung. Und solange sich die Sprache "nicht dazu entschließt", zwischen dem richtigen Ausnahmeobjekt und der primitiven Ziffer zu wählen , bleibt die Verwirrung bestehen.

Die berüchtigte Ungleichheit von NaNsich selbst, beides ==und ===eine Manifestation des verwirrenden Entwurfs, der dieses Ausnahmeobjekt dazu zwingt, ein primitiver Typ zu sein. Dies bricht das Grundprinzip, dass ein Primitiv eindeutig durch seinen Wert bestimmt wird . Wenn NaNes bevorzugt wird, als Ausnahme angesehen zu werden (von der es verschiedene Arten geben kann), sollte es nicht als primitiv "verkauft" werden. Und wenn es primitiv sein soll, muss dieses Prinzip gelten. Solange es kaputt ist, wie wir es in JavaScript getan haben und wir uns nicht wirklich zwischen beiden entscheiden können, bleibt die Verwirrung bestehen, die zu einer unnötigen kognitiven Belastung für alle Beteiligten führt. Was jedoch sehr einfach zu beheben ist, indem Sie einfach die Wahl zwischen beiden treffen:

• Erstellen Sie entweder NaNein spezielles Ausnahmeobjekt, das nützliche Informationen darüber enthält, wie die Ausnahme aufgetreten ist, anstatt diese Informationen als derzeit implementiert wegzuwerfen, was zu einem schwieriger zu debuggenden Code führt.
• oder machen Sie NaNeine Entität vom primitiven Typ number(die weniger verwirrend als "numerisch" bezeichnet werden könnte), in welchem ​​Fall sie sich selbst gleich sein sollte und keine anderen Informationen enthalten kann; Letzteres ist eindeutig eine schlechtere Wahl.

Der einzig denkbare Vorteil zwingt NaNin numberArt ist in der Lage , sie in jeden numerischen Ausdruck zurück zu werfen. Dies macht es jedoch zu einer spröden Wahl, da das Ergebnis eines numerischen Ausdrucks NaNentweder NaNunvorhersehbare Ergebnisse enthält oder zu unvorhersehbaren Ergebnissen führt, z. B. NaN < 0Auswertung zu false, dh Rückkehr booleanstatt Beibehaltung der Ausnahme.

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 dies, diese Ausnahmen zu identifizieren und als Ausnahmen zu behandeln. Was leider mehr Code bedeutet, aber hoffentlich durch Tools wie TypeScript von Flowtype gemildert wird.

Und dann haben wir die Unterscheidung zwischen chaotisch leise und laut, auch bekannt als SignalisierungNaN . Dabei geht es wirklich darum, wie Ausnahmen behandelt werden, nicht um die Ausnahmen selbst und nichts anderes als andere Ausnahmen.

In ähnlicher Weise sind Infinityund +InfinityElemente des numerischen Typs, die in der Verlängerung der reellen Linie auftreten, aber keine reellen Zahlen sind. Mathematisch können sie durch Folgen von reellen Zahlen dargestellt werden, die entweder zu +oder konvergieren -Infinity.

Dies liegt einfach daran, dass NaNes sich um eine Eigenschaft des Number-Objekts in JS handelt. Es hat nichts damit zu tun, dass es sich um eine Zahl handelt.

Der beste Weg, um an NAN zu denken, ist, dass es keine bekannte Zahl ist. Deshalb NAN! = NAN, weil jeder NAN-Wert eine eindeutige unbekannte Zahl darstellt. NANs sind erforderlich, da Gleitkommazahlen einen begrenzten Wertebereich haben. In einigen Fällen tritt eine Rundung auf, wenn die unteren Bits verloren gehen, was zu einem Unsinn wie 1.0 / 11 * 11! = 1.0 führt. Wirklich große Werte, die größer sind, sind NANs, wobei Unendlich ein perfektes Beispiel ist.

Da wir nur zehn Finger haben, ist jeder Versuch, Werte größer als 10 anzuzeigen, unmöglich. Dies bedeutet, dass solche Werte NANs sein müssen, da wir den wahren Wert dieses Werts größer als 10 verloren haben. Gleiches gilt für Gleitkommawerte, bei denen der Wert die Grenzen dessen überschreitet, was in einem Gleitkommawert gehalten werden kann.

Weil NaN ein numerischer Datentyp ist.

NaNist eine Zahl aus Sicht des Typs, aber keine normale Zahl wie 1, 2 oder 329131. Der Name "Not A Number" bezieht sich auf die Tatsache, dass der dargestellte Wert speziell ist und sich auf die IEEE- Formatspezifikationsdomäne bezieht, nicht Javascript-Sprachdomäne.

Wenn Sie jQuery verwenden, ziehe ich es isNumericvor, den Typ zu überprüfen:

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

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

Javascript hat nur einen numerischen Datentyp, nämlich den 64-Bit-Float mit doppelter Genauigkeit. Alles ist doppelt. NaN ist ein spezieller Wert von double, aber es ist trotzdem ein double.

Alles parseInt, was Sie tun müssen, ist, Ihre Zeichenfolge in einen numerischen Datentyp "umzuwandeln". Das Ergebnis ist also immer "Zahl". Nur wenn die ursprüngliche Zeichenfolge nicht analysierbar war, lautet ihr Wert NaN.

NaN ist immer noch ein numerischer Typ, stellt jedoch einen Wert dar, der keine gültige Zahl darstellen kann.

Wir könnten argumentieren, dass NaN ein Sonderfallobjekt ist. In diesem Fall stellt das NaN-Objekt eine Zahl dar, die keinen mathematischen Sinn ergibt. Es gibt einige andere Sonderfallobjekte in der Mathematik wie INFINITE und so weiter.

Sie können noch einige Berechnungen damit durchführen, aber das führt zu seltsamen Verhaltensweisen.

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

Du musst Javascript lieben. Es hat einige interessante kleine Macken.

http://wtfjs.com/page/13

Die meisten dieser Macken können erklärt werden, wenn Sie aufhören, sie logisch zu erarbeiten, oder wenn Sie etwas über die Zahlentheorie wissen, aber sie können Sie trotzdem auffangen, wenn Sie nichts über sie wissen.

Übrigens empfehle ich, den Rest von http://wtfjs.com/ zu lesen - es gibt viel interessantere Macken als diese!

Der Wert NaN ist wirklich die Zahl.NaN. Wenn Sie also fragen, ob es sich um eine Zahl handelt, wird Ja angezeigt. Sie haben mit dem Aufruf isNaN () das Richtige getan.

Zur Information kann NaN auch durch Operationen an Zahlen zurückgegeben werden, die nicht wie Divisionen durch Null oder Quadratwurzel einer negativen Zahl definiert sind.

Ein Beispiel

Stellen Sie sich vor, wir konvertieren eine Zeichenfolge in eine Zahl:

Number("string"); // returns NaN

Wir haben den Datentyp in number geändert, aber sein Wert ist keine Zahl!

Es ist ein spezieller Wert vom Typ Zahl als POSITIVE_INFINITY

Warum? Von Entwurf