JavaScript
Eingebaute Konstanten

Operationen, die NaN zurückgeben

Mathematische Operationen für andere Werte als Zahlen liefern NaN.

"a" + 1
"b" * 3
"cde" - "e"
[1, 2, 3] * 2

Eine Ausnahme: Arrays mit einer einzigen Nummer.

[2] * [3]  // Returns 6

Denken Sie auch daran, dass der Operator + Zeichenfolgen verkettet.

"a" + "b"  // Returns "ab"

Wenn Sie Null durch Null dividieren, erhalten Sie NaN .

0 / 0         // NaN

Hinweis: In der Mathematik ist im Allgemeinen (anders als bei der JavaScript-Programmierung) eine Division durch Null nicht möglich.

Mathematische Bibliotheksfunktionen, die NaN zurückgeben

Im Allgemeinen geben Math Funktionen, die nicht numerische Argumente erhalten, NaN zurück.

Math.floor("a")

Die Quadratwurzel einer negativen Zahl gibt NaN zurück, da Math.sqrt keine imaginären oder komplexen Zahlen unterstützt.

Math.sqrt(-1)

Testen auf NaN mit isNaN ()

window.isNaN()

Mit der globalen Funktion isNaN() kann isNaN() werden, ob ein bestimmter Wert oder Ausdruck zu NaN ausgewertet wird. Diese Funktion (kurz) prüft zuerst, ob der Wert eine Zahl ist, versucht sie nicht (*) und konvertiert dann, ob der resultierende Wert NaN . Aus diesem Grund kann diese Testmethode zu Verwirrung führen .

^{(*) Die "Konvertierungs" -Methode ist nicht so einfach, siehe ECMA-262 18.2.3 für eine detaillierte Erklärung des Algorithmus.}

Diese Beispiele helfen Ihnen, das Verhalten von isNaN() besser zu verstehen:

isNaN(NaN);          // true
isNaN(1);            // false: 1 is a number
isNaN(-2e-4);        // false: -2e-4 is a number (-0.0002) in scientific notation
isNaN(Infinity);     // false: Infinity is a number
isNaN(true);         // false: converted to 1, which is a number
isNaN(false);        // false: converted to 0, which is a number
isNaN(null);         // false: converted to 0, which is a number
isNaN("");           // false: converted to 0, which is a number
isNaN(" ");          // false: converted to 0, which is a number
isNaN("45.3");       // false: string representing a number, converted to 45.3
isNaN("1.2e3");      // false: string representing a number, converted to 1.2e3
isNaN("Infinity");   // false: string representing a number, converted to Infinity
isNaN(new Date);     // false: Date object, converted to milliseconds since epoch
isNaN("10$");        // true : conversion fails, the dollar sign is not a digit
isNaN("hello");      // true : conversion fails, no digits at all
isNaN(undefined);    // true : converted to NaN
isNaN();             // true : converted to NaN (implicitly undefined)
isNaN(function(){}); // true : conversion fails
isNaN({});           // true : conversion fails
isNaN([1, 2]);       // true : converted to "1, 2", which can't be converted to a number

Das letzte ist ein bisschen schwierig: zu prüfen, ob ein Array NaN . Dazu konvertiert der Number() -Konstruktor zuerst das Array in eine Zeichenfolge und dann in eine Zahl. Dies ist der Grund, warum isNaN([]) und isNaN([34]) beide false , aber isNaN([1, 2]) und isNaN([true]) beide true weil sie in "" , "34" , "1,2" bzw. "true" . Im Allgemeinen wird ein Array von isNaN() als NaN isNaN() es sei denn, es enthält nur ein Element, dessen Zeichenfolgendarstellung in eine gültige Zahl umgewandelt werden kann .

// The one and only 
Number.isNaN(NaN);          // true

// Numbers
Number.isNaN(1);            // false
Number.isNaN(-2e-4);        // false
Number.isNaN(Infinity);     // false

// Values not of type number
Number.isNaN(true);         // false
Number.isNaN(false);        // false
Number.isNaN(null);         // false
Number.isNaN("");           // false
Number.isNaN(" ");          // false
Number.isNaN("45.3");       // false
Number.isNaN("1.2e3");      // false
Number.isNaN("Infinity");   // false
Number.isNaN(new Date);     // false
Number.isNaN("10$");        // false
Number.isNaN("hello");      // false
Number.isNaN(undefined);    // false
Number.isNaN();             // false
Number.isNaN(function(){}); // false
Number.isNaN({});           // false
Number.isNaN([]);           // false
Number.isNaN([1]);          // false
Number.isNaN([1, 2]);       // false
Number.isNaN([true]);       // false

Null

null wird zur Darstellung der absichtlichen Abwesenheit eines Objektwerts verwendet und ist ein primitiver Wert. Im Gegensatz zu undefined ist es keine Eigenschaft des globalen Objekts.

Es ist gleich undefined aber nicht identisch damit.

null == undefined; // true
null === undefined; // false

CAREFUL : Der typeof null ist 'object' .

typeof null; // 'object';

Vergleichen Sie den Wert mit dem strengen Gleichheitsoperator , um zu überprüfen, ob ein Wert null ist

var a = null;

a === null; // true

undefined und null

Auf den ersten Blick mag es so aussehen, als seien null und undefined gleich, es gibt jedoch subtile, aber wichtige Unterschiede.

undefined ist das Fehlen eines Werts im Compiler, da dort, wo ein Wert sein sollte, kein Wert angegeben wurde, wie dies bei einer nicht zugewiesenen Variablen der Fall ist.

• undefined ist ein globaler Wert, der das Fehlen eines zugewiesenen Werts darstellt.
  • typeof undefined === 'undefined'
• null ist ein Objekt, das angibt, dass einer Variablen explizit "kein Wert" zugewiesen wurde.
  • typeof null === 'object'

Wenn Sie eine Variable auf undefined , ist die Variable effektiv nicht vorhanden. Einige Prozesse, z. B. die JSON-Serialisierung, können undefined Eigenschaften von Objekten entfernen. Im Gegensatz dazu werden null Eigenschaften beibehalten, sodass Sie das Konzept einer "leeren" Eigenschaft explizit vermitteln können.

Folgendes bewerten zu undefined :

• Eine Variable, wenn sie deklariert ist, aber keinen Wert zugewiesen hat (dh definiert)

  • let foo;
    console.log('is undefined?', foo === undefined);
    // is undefined? true
    

• Zugriff auf den Wert einer Eigenschaft, die nicht vorhanden ist

  • let foo = { a: 'a' };
    console.log('is undefined?', foo.b === undefined);
    // is undefined? true
    

• Der Rückgabewert einer Funktion, die keinen Wert zurückgibt

  • function foo() { return; }
    console.log('is undefined?', foo() === undefined);
    // is undefined? true
    

• Der Wert eines Funktionsarguments, das zwar deklariert wurde, jedoch nicht im Funktionsaufruf enthalten ist

  • function foo(param) { 
      console.log('is undefined?', param === undefined);
    }
    foo('a');
    foo();
    // is undefined? false
    // is undefined? true
    

undefined ist auch eine Eigenschaft des globalen window .

// Only in browsers
console.log(window.undefined); // undefined
window.hasOwnProperty('undefined'); // true    

Unendlichkeit und Unendlichkeit

1 / 0; // Infinity
// Wait! WHAAAT?

Infinity ist eine Eigenschaft des globalen Objekts (daher eine globale Variable), die mathematische Unendlichkeit darstellt. Es ist eine Referenz auf Number.POSITIVE_INFINITY

Es ist größer als jeder andere Wert, und Sie können ihn erhalten, indem Sie durch 0 dividieren oder den Ausdruck einer Zahl bewerten, die so groß ist, dass sie überläuft. Dies bedeutet, dass es in JavaScript keine Division durch 0 Fehler gibt, es gibt Infinity!

Es gibt auch -Infinity das mathematisch negativ unendlich ist, und es ist niedriger als jeder andere Wert.

Um -Infinity zu erhalten, -Infinity Sie Infinity oder erhalten einen Verweis darauf in Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Nun lass uns mit Beispielen Spaß haben:

Infinity > 123192310293; // true
-Infinity < -123192310293; // true
1 / 0; // Infinity
Math.pow(123123123, 9123192391023); // Infinity
Number.MAX_VALUE * 2; // Infinity
23 / Infinity; // 0
-Infinity; // -Infinity
-Infinity === Number.NEGATIVE_INFINITY; // true
-0; // -0 , yes there is a negative 0 in the language
0 === -0; // true
1 / -0; // -Infinity
1 / 0 === 1 / -0; // false
Infinity + Infinity; // Infinity

var a = 0, b = -0;

a === b; // true
1 / a === 1 / b; // false

// Try your own!

NaN

NaN steht für "Not a Number". Wenn eine mathematische Funktion oder Operation in JavaScript keine bestimmte Zahl zurückgeben kann, wird stattdessen der Wert NaN .

Es ist eine Eigenschaft des globalen Objekts und eine Referenz auf Number.NaN

window.hasOwnProperty('NaN'); // true
NaN; // NaN

Vielleicht verwirrend wird NaN immer noch als Zahl betrachtet.

typeof NaN; // 'number'

Suchen Sie nicht mit dem Gleichheitsoperator nach NaN . Siehe stattdessen isNaN .

NaN == NaN  // false
NaN === NaN // false

Anzahl Konstanten

Der Number Konstruktor verfügt über einige eingebaute Konstanten, die nützlich sein können

Number.MAX_VALUE;          // 1.7976931348623157e+308
Number.MAX_SAFE_INTEGER;   // 9007199254740991

Number.MIN_VALUE;          // 5e-324
Number.MIN_SAFE_INTEGER;   // -9007199254740991

Number.EPSILON;            // 0.0000000000000002220446049250313

Number.POSITIVE_INFINITY;  // Infinity
Number.NEGATIVE_INFINITY;  // -Infinity

Number.NaN;                // NaN

In vielen Fällen sind die verschiedenen Akteure in Javascript mit Werten außerhalb des Bereichs brechen wird von ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Beachten Sie, dass Number.EPSILON den Unterschied zwischen einer und der kleinsten Number größer als eins darstellt und somit die kleinstmögliche Differenz zwischen zwei verschiedenen Number Werten. Ein Grund, dies zu verwenden, liegt in der Art und Weise, wie Zahlen von JavaScript gespeichert werden. Siehe Gleichheit zweier Zahlen prüfen