So implementieren Sie Additions-, Subtraktions-, Multiplikations- und Divisionsoperationen in Javascript

Additionsoperator

Beispiel 1

Achten Sie auf die Summationsoperation spezieller Operanden.

var n = 5;  //定义并初始化任意一个数值
console.log(NaN + n);  //NaN与任意操作数相加，结果都是NaN
console.log(Infinity + n);  //Infinity与任意操作数相加，结果都是Infinity
console.log(Infinity + Infinity);  //Infinity与Infinity相加，结果是Infinity
console.log((-Infinity) + (-Infinity));  //负Infinity相加，结果是负Infinity
console.log((-Infinity) + Infinity);  //正负Infinity相加，结果是NaN

Beispiel 2

Der Additionsoperator kann basierend auf dem Datentyp der Operanden entscheiden, ob er addiert oder verbindet.

console.log(1 + 1);  //如果操作数都是数值，则进行相加运算
console.log(1 + "1");  //如果操作数中有一个是字符串，则进行相连运算
console.log(3.0 + 4.3 + "");  //先求和，再连接，返回"7.3"
console.log(3.0 + "" + 4.3);  //先连接，再连接，返回"34.3"
                              //3.0转换为字符串3

Bei Verwendung des Additionsoperators sollten Sie zunächst prüfen, ob der Datentyp des Operanden den Anforderungen entspricht.

Subtraktionsoperator

Beispiel 1

Achten Sie auf die Subtraktionsoperation spezieller Operanden.

var n = 5;  //定义并初始化任意一个数值
console.log(NaN - n);  //NaN与任意操作数相减，结果都是NaN
console.log(Infinity - n);  //Infinity与任意操作数相减，结果都是Infinity
console.log(Infinity - Infinity);  //Infinity与Infinity相减，结果是NaN
console.log((-Infinity) - (-Infinity));  //负Infinity相减，结果是NaN
console.log((-Infinity) - Infinity);  //正负Infinity相减，结果是-Infinity

Beispiel 2

Wenn der Operand in der Subtraktionsoperation eine Zeichenfolge ist, versuchen Sie, ihn in einen numerischen Wert umzuwandeln, bevor Sie die Operation ausführen. Wenn einer der Operanden keine Zahl ist, wird NaN zurückgegeben.

console.log(2 - "1");  //返回1
console.log(2 - "a");  //返回NaN

Verwenden Sie den Wert minus 0, um den Wert schnell in eine Zahl umzuwandeln. Beispielsweise handelt es sich bei Abfragezeichenfolgen in HTTP-Anforderungen im Allgemeinen um Zeichenfolgenzahlen. Von diesen Parameterwerten können Sie zunächst 0 abziehen, um sie in numerische Werte umzuwandeln. Dies hat das gleiche Ergebnis wie der Aufruf der Methode parseFloat(), die Subtraktion ist jedoch effizienter und schneller. Implizite Konvertierungen mit dem Subtraktionsoperator geben NaN zurück, wenn sie fehlschlagen, was sich vom Rückgabewert unterscheidet, wenn die Konvertierung mit der Methode parseFloat() durchgeführt wird.

Zum Beispiel kann die Methode parseFloat() für die Zeichenfolge „100aaa“ die ersten paar Zahlen analysieren, aber für den Subtraktionsoperator muss es eine vollständige Zahl sein, bevor sie konvertiert werden kann.

console.log(parseFloat("100aaa"));  //返回100
console.log("100aaa" - 0);  //返回NaN

Für boolesche Werte kann die Methode parseFloat() „true“ in 1 und „false“ in 0 konvertieren, während der Subtraktionsoperator sie als NaN behandelt.

Bei Objekten versucht die parseFloat()-Methode, die toString()-Methode des Objekts zur Konvertierung aufzurufen, während der Subtraktionsoperator zunächst versucht, die valueOf()-Methode des Objekts zur Konvertierung aufzurufen, und nach einem Fehler dann toString() zur Konvertierung aufruft .

Multiplikationsoperator

Achten Sie auf die Multiplikationsoperation spezieller Operanden.

var n = 5;  //定义并初始化任意一个数值
console.log(NaN * n);  //NaN与任意操作数相乘，结果都是NaN
console.log(Infinity * n);  //Infinity与任意非零正数相乘，结果都是Infinity
console.log(Infinity * (- n));  //Infinity与任意非零负数相乘，结果是-Infinity
console.log(Infinity * 0);  //Infinity与0相乘，结果是NaN
console.log(Infinity * Infinity);  //Infinity与Infinity相乘，结果是Infinity

Divisionsoperator

Achten Sie auf die Divisionsoperation spezieller Operanden.

var  n = 5;  //定义并初始化任意一个数值
console.log(NaN / n);  //如果一个操作数是NaN，结果都是NaN
console.log(Infinity / n);  //Infinity被任意数字除，结果是Infinity或-Infinity
                            //符号由第二个操作数的符号决定
console.log(Infinity / Infinity);  //返回NaN
console.log(n / 0);  //0除一个非无穷大的数字，结果是Infinity或-Infinity，符号由第二个操作数的符号决定
console.log(n / -0);  //返回-Infinity，解释同上

Restoperator

Die Restoperation wird auch als modulare Operation bezeichnet. Zum Beispiel:

console.log(3 % 2);  //返回余数1

Die modulare Operation arbeitet hauptsächlich mit ganzen Zahlen, gilt aber auch für Gleitkommazahlen. Zum Beispiel:

console.log(3.1 % 2.3);  //返回余数0.8000000000000003

Beispiel

Achten Sie auf die Restoperation spezieller Operanden.

var n = 5;  //定义并初始化任意一个数值
console.log(Infinity % n);  //返回NaN
console.log(Infinity % Infinity);  //返回NaN
console.log(n % Infinity);  //返回5
console.log(0 % n);  //返回0
console.log(0 % Infinity);  //返回0
console.log(n % 0);  //返回NaN
console.log(Infinity % 0);  //返回NaN

2: Zuweisungsoperator

Der Zuweisungsoperator wird zum Zuweisen von Werten zu Variablen verwendet. Er hat die folgenden zwei Formen:

• Einfache Zuweisungsoperation =: Kopiert den Wert des Operanden direkt weiter Die rechte Seite des Gleichheitszeichens wird dem linken Operanden zugewiesen, sodass sich der Wert des linken Operanden ändert.

• Zuweisungsoperation zusätzlicher Operationen: Führen Sie vor der Zuweisung eine Operation am rechten Operanden aus und kopieren Sie dann das Operationsergebnis in den linken Operanden.

Einige zusätzliche Operationen und Zuweisungsoperationen können die vier arithmetischen Operationen Addition, Subtraktion, Multiplikation und Division realisieren. Die spezifische Beschreibung ist in der Tabelle aufgeführt:

Subtraktionsoperation und Zuweisung

a= a - b

var x = 10;
x += 20;
console.log(x);  // 输出：30
var x = 12,
    y = 7;
x -= y;
console.log(x);  // 输出：5
x = 5;
x *= 25;
console.log(x);  // 输出：125
x = 50;
x /= 10;
console.log(x);  // 输出：5
x = 100;
x %= 15;
console.log(x);  // 输出：10

Name

Auswirkung ++x

var x;

x = 10;
console.log(++x);  // 输出：11
console.log(x);    // 输出：11

x = 10;
console.log(x++);  // 输出：10
console.log(x);    // 输出：11

x = 10;
console.log(--x);  // 输出：9
console.log(x);    // 输出：9

x = 10;
console.log(x--);  // 输出：10
console.log(x);    // 输出：9