In JavaScript können mathematische Operationen durch zwei Operationen implementiert werden:
1. +, -, *, /, % und andere Betreiber.
2. Verwenden Sie die Berechnungsfunktion des Mathematikobjekts. Verwenden Sie beispielsweise Math.Pow (2,3), um die Leistung von 2 bis 3 zu berechnen.
Im Gegensatz zu Java werfen mathematische Operationen in JavaScript keine Fehler. Der Überlauf des Berechnungsergebnisses, die sich durch 0 und quadratische negative Zahlen dividieren, sind alle legal, und das Ergebnis ist ein besonderer Wert in JavaScript: plus oder negatives Unendlichkeit (unendlich), plus oder negativ 0, NAN (nicht nummer):
1. positive und negative Unendlichkeit. Wenn das Berechnungsergebnis größer ist als die maximale Zahl, die JavaScript darstellen kann (number.max_value), ist das Ergebnis eine positive Unendlichkeit; Wenn das Berechnungsergebnis kleiner als die minimale Zahl ist, die JavaScript darstellen kann (-Number.max_value), ist das Ergebnis eine negative Unendlichkeit. Die mathematischen Operationen wie +, -, *und / im Zusammenhang mit Unendlichkeit folgen alle den Regeln der Grenzberechnung in der erweiterten Mathematik. Das Ergebnis von 1/0 ist eine positive Unendlichkeit, und das Ergebnis von -1/0 ist negativer Unendlichkeit.
2. Plus oder minus 0. Wenn das Berechnungsergebnis positiv ist, aber geringer als die minimale Dezimalzahl (Zahl.min_Value), die JavaScript darstellen kann, ist das Ergebnis positiv 0; Wenn das Berechnungsergebnis negativ ist, aber größer als die maximale negative Dezimalzahl (-nummer
3.Nan. Für einige spezielle Berechnungsergebnisse, die auch bei positiver und negativer Unendlichkeit nicht dargestellt werden können, verwendet JavaScript NAN, um sie darzustellen (es ist erwähnenswert, dass Nan zwar wörtlich "nicht nummerieren" bedeutet, seine Art jedoch die Zahl ist). Diese besonderen Berechnungen umfassen:
1) .0/0.
2) .Infinity/Infinity.
3). Quadratische negative Zahlen.
4). Führen Sie numerische Konvertierungsoperationen für nicht numerische Zeichenfolgen durch.
Für Infinity und NAN sind sie sowohl "unendliche" als auch "nicht nummerierte" Druckergebnisse und auch globale Variablennamen, die diese beiden speziellen Werte in JavaScript darstellen. In der Tat können diesen beiden globalen Variablen in ECMascript 3 auch andere Werte zugeordnet werden. Diese verrückte Regel wurde in ECMascript 5 korrigiert, um diese beiden globalen Variablen schreibgeschützt zu machen. Zusätzlich zum direkten Zugriff auf die Infinity -Variable und die NAN -Variable können Sie diese beiden Sonderwerte auch verwenden, indem Sie auf die Mitgliedsvariablen des Zahlenobjekts zugreifen:
1.Infinity entspricht der Zahl.Positiv_infinity.
2. Infinity entspricht der Zahl.negative_Infinity.
3.Nan entspricht der Zahl.nan.
In JavaScript ist NAN ein interessanter besonderer Wert, der eine spezielle Eigenschaft hat: Es entspricht keinem anderen Wert (einschließlich sich selbst). Es gibt zwei Möglichkeiten, um festzustellen, ob ein Wert NAN ist:
1. Für die Variable X bestimmen Sie, ob x! = X wahr ist. Dieser Ausdruck ist nur dann wahr, wenn x Nan ist.
2. Für die Variable X rufen Sie die globale Funktion isnan () in JavaScript auf, um festzustellen, ob ISNAN (x) wahr ist. Diese Methode bestimmt, dass NAN nicht wirklich streng ist, da der Ausdruck in 4 Fällen wahr ist:
1) .x ist nan.
2) .x ist eine Zeichenfolge und die Zeichenfolge ist keine Zahl.
3) .x ist ein Objekt.
4) .x ist undefiniert.
Zusätzlich zu ISNAN () hat JavaScript eine andere nützliche globale Funktion: isfinite (). Für die Variable A ist Isfinite (a) in den folgenden Fällen wahr:
1) .a ist Zahl, aber nicht Nan oder positiver und negativer Unendlichkeit.
2) .a ist eine Zeichenfolge, aber der Inhalt der Zeichenfolge ist eine nicht-positive Unendlichkeitszahl.
3) .a ist null.
4) .A ist der boolesche Wert.
Da nicht numerische Typen wie Null und Undefined Auswirkungen auf das Ergebnis haben, denke ich persönlich, dass es am besten ist, den Typ des Parameters zu beurteilen, bevor ISNAN () oder ISFINIT () verwendet wird.
Experiment
Die Codekopie lautet wie folgt:
// Unendlichkeit testen
var a = number.max_value;
console.log (a*1.1); // unendlich
console.log (a*-1.1); //-Infinity
console.log (1/0); // unendlich
console.log (-1/0); //-Infinity
// positive/negative 0 testen
var b = number.min_value;
console.log (b/2); // 0
console.log (-b/2); // 0
// Nan testen
console.log (0/0); // nan
console.log (unendlich/unendlich); // nan
console.log (math.sqrt (-1)); // nan
console.log (parseInt ("String")); // nan
// Infinity -Vergleich testen
console.log (Infinity === number.positiv_infinity); // true
console.log (-infinity === number.negative_infinity); // true
// Nan -Vergleich testen
console.log (nan === nan); // false
// test isnan ()
console.log (isnan (nan)); // true
console.log (isnan ("42"); // false
console.log (isnan ("String")); // true
console.log (isnan ({})); // true
console.log (isnan (undefiniert)); // true
console.log (isnan (null)); // false
// isFinite () testen Sie
console.log (isfinite (42)); // true
console.log (isfinite (unendlich)); // false
console.log (isfinite (nan)); // false
console.log (isfinite ("29"); // true
console.log (isfinite ("String")); // false
console.log (isfinite (null)); // true
console.log (isfinite (undefined)); // false
console.log (isfinite (true)); // true
console.log (isfinite (false)); // true