NaN ist der einzige Wert, der nicht gleich sich selbst ist:

> NaN === NaN
false

Strikte Gleichheit (===) wird auch von Array.prototype.indexOf verwendet. Sie können daher NaN mit dieser Methode nicht in einem Array suchen.

> [ NaN ].indexOf(NaN)
-1

Wenn Sie prüfen möchten, ob ein Wert NaN ist, müssen Sie die globale Funktion isNaN() verwenden:

> isNaN(NaN)
true
> isNaN(33)
false

Allerdings funktioniert isNaN nicht richtig mit Nicht-Zahlen, da es diese zuerst in Zahlen umwandelt. Diese Umwandlung kann NaN ergeben und dann gibt die Funktion fälschlicherweise true zurück.

> isNaN('xyz')
true

Daher ist es am besten, isNaN mit einer Typüberprüfung zu kombinieren:

function myIsNaN(value) {
    return typeof value === 'number' && isNaN(value);
}

Alternativ können Sie prüfen, ob der Wert ungleich sich selbst ist (da NaN der einzige Wert mit diesem Merkmal ist). Aber das ist weniger selbsterklärend:

function myIsNaN(value) {
    return value !== value;
}

Beachten Sie, dass dieses Verhalten durch IEEE 754 diktiert wird. Wie in Abschnitt 7.11, „Details von Vergleichsprädikaten“ erwähnt:^[15]

Wie groß der Betrag einer Zahl sein kann, wird durch ihre interne Darstellung bestimmt (wie in Die interne Darstellung von Zahlen diskutiert), die das arithmetische Produkt von ist

Der Exponent muss zwischen −1023 und 1024 (ausschließlich) liegen. Wenn der Exponent zu klein ist, wird die Zahl 0. Wenn der Exponent zu groß ist, wird sie Infinity. 2¹⁰²³ kann noch dargestellt werden, aber 2¹⁰²⁴ nicht.

> Math.pow(2, 1023)
8.98846567431158e+307
> Math.pow(2, 1024)
Infinity

Die Division durch Null ergibt Infinity als Fehlerwert:

> 3 / 0
Infinity
> 3 / -0
-Infinity

Sie erhalten das Fehlerergebnis NaN, wenn Sie versuchen, eine Infinity mit einer anderen zu „neutralisieren“:

> Infinity - Infinity
NaN
> Infinity / Infinity
NaN

Wenn Sie versuchen, über Infinity hinauszugehen, erhalten Sie immer noch Infinity.

> Infinity + Infinity
Infinity
> Infinity * Infinity
Infinity

Strikte und tolerante Gleichheit funktionieren für Infinity einwandfrei:

> var x = Infinity;
> x === Infinity
true

Zusätzlich erlaubt die globale Funktion isFinite() Ihnen zu überprüfen, ob ein Wert eine tatsächliche Zahl ist (weder unendlich noch NaN):

> isFinite(5)
true
> isFinite(Infinity)
false
> isFinite(NaN)
false

JavaScript tut viel, um zu verbergen, dass es zwei Nullen gibt. Da es normalerweise keine Rolle spielt, dass sie unterschiedlich sind, wird empfohlen, dass Sie sich der Illusion der einzelnen Null anschließen. Untersuchen wir, wie diese Illusion aufrechterhalten wird.

In JavaScript schreiben Sie normalerweise 0, was +0 bedeutet. Aber -0 wird auch einfach als 0 angezeigt. Das sehen Sie, wenn Sie eine Browser-Befehlszeile oder die Node.js REPL verwenden.

> -0
0

Das liegt daran, dass die Standardmethode toString() beide Nullen in dieselbe '0' umwandelt:

> (-0).toString()
'0'
> (+0).toString()
'0'

Gleichheit unterscheidet Nullen ebenfalls nicht. Nicht einmal ===:

> +0 === -0
true

Array.prototype.indexOf verwendet ===, um nach Elementen zu suchen, und wahrt so die Illusion.

> [ -0, +0 ].indexOf(+0)
0
> [ +0, -0 ].indexOf(-0)
0

Die Ordnungsoperatoren betrachten die Nullen ebenfalls als gleich.

> -0 < +0
false
> +0 < -0
false

Wie kann man tatsächlich beobachten, dass die beiden Nullen unterschiedlich sind? Man kann durch Null teilen (-Infinity und +Infinity können durch === unterschieden werden):

> 3 / -0
-Infinity
> 3 / +0
Infinity

Eine weitere Möglichkeit, die Division durch Null durchzuführen, ist über Math.pow() (siehe Numerische Funktionen)

> Math.pow(-0, -1)
-Infinity
> Math.pow(+0, -1)
Infinity

Math.atan2() (siehe Trigonometrische Funktionen) enthüllt ebenfalls, dass die Nullen unterschiedlich sind:

> Math.atan2(-0, -1)
-3.141592653589793
> Math.atan2(+0, -1)
3.141592653589793

Die kanonische Methode zur Unterscheidung der beiden Nullen ist die Division durch Null. Daher würde eine Funktion zur Erkennung negativer Nullen wie folgt aussehen:

function isNegativeZero(x) {
    return x === 0 && (1/x < 0);
}

Hier ist die Funktion in Aktion.

> isNegativeZero(0)
false
> isNegativeZero(-0)
true
> isNegativeZero(33)
false

Wenn Sie mit ganzen Zahlen bis zu einem Betrag von 53 Bits arbeiten, sind Sie auf der sicheren Seite. Leider stoßen Sie in der Programmierung oft auf 64-Bit-Ganzzahlen ohne Vorzeichen (Twitter-IDs, Datenbanken usw.). Diese müssen in JavaScript in Zeichenketten gespeichert werden. Wenn Sie Berechnungen mit solchen ganzen Zahlen durchführen möchten, benötigen Sie spezielle Bibliotheken. Es gibt Pläne, größere ganze Zahlen in JavaScript einzuführen, aber das wird noch eine Weile dauern.

ECMAScript 6 wird die folgenden Konstanten bereitstellen:

Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;

Es wird auch eine Funktion bereitstellen, um festzustellen, ob eine Ganzzahl sicher ist:

Number.isSafeInteger = function (n) {
    return (typeof n === 'number' &&
        Math.round(n) === n &&
        Number.MIN_SAFE_INTEGER <= n &&
        n <= Number.MAX_SAFE_INTEGER);
}

Für einen gegebenen Wert n prüft diese Funktion zuerst, ob n eine Zahl und eine ganze Zahl ist. Wenn beide Prüfungen erfolgreich sind, ist n sicher, wenn es größer oder gleich MIN_SAFE_INTEGER und kleiner oder gleich MAX_SAFE_INTEGER ist.

Wie können wir sicherstellen, dass Ergebnisse von arithmetischen Berechnungen korrekt sind? Zum Beispiel ist das folgende Ergebnis eindeutig nicht korrekt:

> 9007199254740990 + 3
9007199254740992

Wir haben zwei sichere Operanden, aber ein unsicheres Ergebnis.

> Number.isSafeInteger(9007199254740990)
true
> Number.isSafeInteger(3)
true
> Number.isSafeInteger(9007199254740992)
false

Das folgende Ergebnis ist ebenfalls falsch.

> 9007199254740995 - 10
9007199254740986

Diesmal ist das Ergebnis sicher, aber einer der Operanden ist es nicht.

> Number.isSafeInteger(9007199254740995)
false
> Number.isSafeInteger(10)
true
> Number.isSafeInteger(9007199254740986)
true

Daher ist das Ergebnis der Anwendung eines Ganzzahloperators op nur dann garantiert korrekt, wenn alle Operanden und das Ergebnis sicher sind. Formaler:

isSafeInteger(a) && isSafeInteger(b) && isSafeInteger(a op b)

impliziert, dass a op b ein korrektes Ergebnis ist.

Wenn die Maske, der zweite Operand, 0 ist, ändern Sie keine Bits und das Ergebnis ist der erste Operand, umgewandelt in eine vorzeichenbehaftete 32-Bit-Ganzzahl. Dies ist die kanonische Methode, diese Art von Umwandlung durchzuführen, und wird z. B. von asm.js verwendet (siehe Ist JavaScript schnell genug?)

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x | 0;
}

ToInt32() entfernt den Bruch und wendet Modulo 2³² an:

> ToInt32(1.001)
1
> ToInt32(1.999)
1
> ToInt32(1)
1
> ToInt32(-1)
-1
> ToInt32(Math.pow(2, 32)+1)
1
> ToInt32(Math.pow(2, 32)-1)
-1

Der gleiche Trick, der für bitweises ODER funktionierte, funktioniert auch für Schiebeoperatoren: wenn Sie um null Bits verschieben, ist das Ergebnis einer Schiebeoperation der erste Operand, umgewandelt in eine 32-Bit-Ganzzahl. Hier sind einige Beispiele für die Implementierung von Operationen der ECMAScript-Spezifikation über Schiebeoperatoren:

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x << 0;
}

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x >> 0;
}

// Convert x to an unsigned 32-bit integer
function ToUint32(x) {
    return x >>> 0;
}

Hier ist ToUint32() in Aktion:

> ToUint32(-1)
4294967295
> ToUint32(Math.pow(2, 32)-1)
4294967295
> ToUint32(Math.pow(2, 32))
0

Sie müssen selbst entscheiden, ob der geringe Effizienzgewinn es wert ist, dass Ihr Code schwerer zu verstehen ist. Beachten Sie auch, dass bitweise Operatoren sich künstlich auf 32 Bits beschränken, was oft weder notwendig noch nützlich ist. Die Verwendung einer der Math-Funktionen, möglicherweise in Verbindung mit Math.abs(), ist eine selbsterklärendere und arguably bessere Wahl.

Der Wertebereich für die Radix ist 2 ≤ radix ≤ 36. Sie bestimmt die Basis der zu parsierenden Zahl. Wenn die Radix größer als 10 ist, werden zusätzlich zu 0–9 Buchstaben als Ziffern verwendet (Groß- und Kleinschreibung wird nicht beachtet).

Wenn radix fehlt, wird angenommen, dass sie 10 ist, es sei denn, str beginnt mit „0x“ oder „0X“, in welchem Fall radix auf 16 (hexadezimal) gesetzt wird.

> parseInt('0xA')
10

Wenn radix bereits 16 ist, ist das hexadezimale Präfix optional.

> parseInt('0xA', 16)
10
> parseInt('A', 16)
10

Bisher habe ich das Verhalten von parseInt() gemäß der ECMAScript-Spezifikation beschrieben. Zusätzlich setzen einige Engines die Radix auf 8, wenn str mit einer Null beginnt.

> parseInt('010')
8
> parseInt('0109')  // ignores digits ≥ 8
8

Daher ist es am besten, die Radix immer explizit anzugeben und parseInt() immer mit zwei Argumenten aufzurufen.

Hier sind einige Beispiele.

> parseInt('')
NaN
> parseInt('zz', 36)
1295
> parseInt('   81', 10)
81

> parseInt('12**', 10)
12
> parseInt('12.34', 10)
12
> parseInt(12.34, 10)
12

Verwenden Sie parseInt() nicht, um eine Zahl in einen Integer umzuwandeln. Das letzte Beispiel gibt uns Hoffnung, dass wir parseInt() für die Konvertierung von Zahlen in Integer verwenden können. Leider gibt es hier ein Beispiel, bei dem die Konvertierung falsch ist:

> parseInt(1000000000000000000000.5, 10)
1

Das Argument wird zuerst in einen String konvertiert.

> String(1000000000000000000000.5)
'1e+21'

parseInt betrachtet „e“ nicht als Integer-Ziffer und stoppt daher das Parsen nach der 1. Hier ist ein weiteres Beispiel:

> parseInt(0.0000008, 10)
8
> String(0.0000008)
'8e-7'

parseInt() sollte nicht verwendet werden, um Zahlen in Integer umzuwandeln: Die Typumwandlung in einen String ist ein unnötiger Umweg und selbst dann ist das Ergebnis nicht immer korrekt.

parseInt() ist nützlich für das Parsen von Strings, aber man muss sich bewusst sein, dass es beim ersten illegalen Zeichen stoppt. Das Parsen von Strings über Number() (siehe Die Funktion Number) ist weniger nachsichtig, kann aber zu Nicht-Integer-Ergebnissen führen.

Zwei gängige Methoden zur Berechnung eines binären Komplements (oder Inversen) einer Binärzahl sind:

32-Bit-Integer haben kein explizites Vorzeichen, aber Sie können trotzdem negative Zahlen kodieren. Zum Beispiel kann −1 als Zweierkomplement von 1 kodiert werden: Wenn Sie 1 zum Ergebnis addieren, erhalten Sie 0 (innerhalb von 32 Bit). Die Grenze zwischen positiven und negativen Zahlen ist fließend; 4294967295 (2³²−1) und −1 sind hier derselbe Integer. Sie müssen sich jedoch für ein Vorzeichen entscheiden, wenn Sie einen solchen Integer von oder zu einer JavaScript-Zahl konvertieren, die ein explizites Vorzeichen hat, im Gegensatz zu einem impliziten. Daher sind vorzeichenbehaftete 32-Bit-Integer in zwei Gruppen unterteilt:

Das höchstwertige Bit wird oft als Vorzeichenbit bezeichnet. Entsprechend wird 4294967295, interpretiert als vorzeichenbehafteter 32-Bit-Integer, zu −1, wenn es in eine JavaScript-Zahl konvertiert wird.

> ToInt32(4294967295)
-1

ToInt32() wird in 32-Bit-Integer über Bitwise-Operatoren erläutert.

In den folgenden Beispielen arbeiten wir mit binären Zahlen über die folgenden beiden Operationen:

Für die Radix 10 verwendet toString() in zwei Fällen eine Exponentialnotation (mit einer einzelnen Ziffer vor dem Dezimalpunkt). Erstens, wenn mehr als 21 Ziffern vor dem Dezimalpunkt einer Zahl vorhanden sind.

> 1234567890123456789012
1.2345678901234568e+21
> 123456789012345678901
123456789012345680000

Zweitens, wenn eine Zahl mit 0. beginnt, gefolgt von mehr als fünf Nullen und einer Nicht-Null-Ziffer.

> 0.0000003
3e-7
> 0.000003
0.000003

In allen anderen Fällen wird eine feste Notation verwendet.