Einführung in mathematische Operationen in JavaScript_Javascript-Kenntnissen

In JavaScript können mathematische Operationen durch zwei Operationen implementiert werden:

1. , -, *, /, % und andere Operatoren.
2. Verwenden Sie die Berechnungsfunktion des Math-Objekts. Verwenden Sie beispielsweise Math.pow(2,3), um 2 hoch in die dritte Potenz zu berechnen.

Im Gegensatz zu Java verursachen mathematische Operationen in JavaScript keine Fehler. Operationen wie das Überlaufen von Berechnungsergebnissen, das Teilen durch 0 und das Ziehen der Quadratwurzel aus negativen Zahlen sind alle zulässig. Die Ergebnisse sind spezielle Werte in JavaScript: positive und negative Unendlichkeit (Unendlichkeit), positive und negative 0, NaN (nicht a Nummer):

1. Positive und negative Unendlichkeit. Wenn das Berechnungsergebnis größer als die maximale Zahl ist, die JavaScript darstellen kann (Number.MAX_VALUE), ist das Ergebnis positiv. Wenn das Berechnungsergebnis kleiner als die minimale Zahl ist, die JavaScript darstellen kann (-Number.MAX_VALUE), ist das Ergebnis negative Unendlichkeit. Mathematische Operationen wie , -, * und / im Zusammenhang mit der Unendlichkeit folgen den Regeln der Grenzwertberechnung in der fortgeschrittenen Mathematik. Das Ergebnis von 1/0 ist eine positive Unendlichkeit, und das Ergebnis von -1/0 ist eine negative Unendlichkeit.

2. Plus oder minus 0. Wenn das Berechnungsergebnis positiv ist, aber kleiner als die kleinste Dezimalzahl, die JavaScript darstellen kann (Number.MIN_VALUE), ist das Ergebnis positiv 0; wenn das Berechnungsergebnis negativ ist, aber größer als die größte negative Dezimalzahl, die JavaScript darstellen kann (-Number). .MIN_VALUE), das Ergebnis ist negativ 0. Normalerweise müssen sich Entwickler nicht um die Differenz zwischen positiven und negativen 0 kümmern.

3,NaN. Für einige spezielle Berechnungsergebnisse, die nicht einmal mit positiver und negativer Unendlichkeit ausgedrückt werden können, verwendet JavaScript NaN zur Darstellung (es ist erwähnenswert, dass NaN zwar wörtlich „keine Zahl“ bedeutet, sein Typ jedoch Zahl ist). Zu diesen Sonderberechnungen gehören:

1).0/0.
2).Unendlich/Unendlich.
3) Ziehen Sie die Quadratwurzel aus negativen Zahlen.
4) Führen Sie numerische Konvertierungsoperationen für nicht numerische Zeichenfolgen durch.

Für Infinity und NaN handelt es sich nicht nur um die gedruckten Ergebnisse von „unendlich“ und „keine Zahl“, sondern auch um die globalen Variablennamen, die diese beiden Sonderwerte in JavaScript darstellen. Tatsächlich können diesen beiden globalen Variablen in ECMAScript 3 auch andere Werte zugewiesen werden. Diese ärgerliche Regel wurde in ECMAScript 5 überarbeitet, sodass diese beiden globalen Variablen schreibgeschützt sind. Zusätzlich zum direkten Zugriff auf die Infinity-Variablen und die NaN-Variablen können Sie diese beiden Sonderwerte auch verwenden, indem Sie auf die Mitgliedsvariablen des Number-Objekts zugreifen:

1.Infinity entspricht Number.POSITIVE_INFINITY.
2.-Infinity entspricht Number.NEGATIVE_INFINITY.
3.NaN entspricht Number.NaN.

In JavaScript ist NaN ein sehr interessanter Sonderwert. Er hat eine besondere Eigenschaft: Er ist mit keinem anderen Wert (einschließlich sich selbst) gleich. Es gibt zwei Möglichkeiten zu bestimmen, ob ein Wert NaN ist:

1. Bestimmen Sie für die Variable x, ob x!=x wahr ist. Dieser Ausdruck ist nur wahr, wenn x NaN ist.

2. Rufen Sie für die Variable x die globale Funktion isNaN() in JavaScript auf, um zu bestimmen, ob isNaN(x) wahr ist. Die Verwendung dieser Methode zur Bestimmung von NaN ist eigentlich nicht streng, da der Ausdruck isNaN(x) in vier 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() verfügt JavaScript über eine weitere nützliche globale Funktion: isFinite(). Für die Variable a ist isFinite(a) in den folgenden Situationen wahr:

1).a ist eine Zahl, aber nicht NaN oder positive oder negative Unendlichkeit.
2).a ist eine Zeichenfolge, aber der Inhalt der Zeichenfolge ist eine nicht NaN, nicht positive oder negative Unendlichkeitszahl.
3).a ist null.
4).a ist ein boolescher Wert.

Da nicht-numerische Typen wie null und undefiniert das Ergebnis beeinflussen, halte ich es persönlich für das Beste, den Typ des Parameters zu bestimmen, bevor man isNaN() oder isFinite() verwendet.

Experimentieren

Code kopieren Der Code lautet wie folgt:

//Unendlichkeit testen
var a = Number.MAX_VALUE;
console.log(a*1.1);//Infinity
console.log(a*-1.1);//-Infinity
console.log(1/0);//Infinity
console.log(-1/0);//-Infinity

//Test positiv/negativ 0
var b = Number.MIN_VALUE;
console.log(b/2);//0
console.log(-b/2);//0

//NaN testen
console.log(0/0);//NaN
console.log(Infinity/Infinity);//NaN
console.log(Math.sqrt(-1));//NaN
console.log(parseInt("string"));//NaN

//Infinity-Vergleich testen
console.log(Infinity === Number.POSITIVE_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

//Test isFinite()
console.log(isFinite(42));//true
console.log(isFinite(Infinity));//false
console.log(isFinite(NaN));//false
console.log(isFinite("29"));//true
console.log(isFinite("string"));//false
console.log(isFinite(null));//true
console.log(isFinite(undefiniert));//false
console.log(isFinite(true));//true
console.log(isFinite(false));//true