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

Implementierungsmethode: 1. Verwenden Sie die Symbole „+“, „-“, „*“, „/“ und „%“, um Additions-, Subtraktions-, Multiplikations-, Divisions- und Restoperationen zu implementieren. 2. Verwenden Sie „+=". Die Symbole „-=", „*=" und „/=" führen zunächst Additions-, Subtraktions-, Multiplikations- und Divisionsoperationen aus und weisen dann die Ergebnisse den Variablen auf der linken Seite des Operators zu. 3. Verwenden Sie die Funktion „; ++x“- oder „x++“-Symbole Der Wert der Variablen wird erhöht (+1), und das Zeichen „--x“ oder „x--“ wird verwendet, um den Wert der Variablen zu dekrementieren (-1).

Die Betriebsumgebung dieses Tutorials: Windows 7-System, JavaScript-Version 1.8.5, Dell G3-Computer.

In JavaScript können Operatoren verwendet werden, um die vier arithmetischen Operationen Addition, Subtraktion, Multiplikation und Division zu implementieren. Operatoren sind Symbole, mit denen die JavaScript-Engine angewiesen wird, eine bestimmte Operation auszuführen. Das Pluszeichen (+) steht beispielsweise für die Addition, das Minuszeichen (-) für die Subtraktion usw.

1: Arithmetische Operatoren

Arithmetische Operatoren werden zum Ausführen allgemeiner mathematischer Operationen wie Addition, Subtraktion, Multiplikation, Division usw. verwendet. In der folgenden Tabelle sind die in JavaScript unterstützten arithmetischen Operatoren aufgeführt:

描 Curchase述 Beschreibung erfolgt Subtraktionsoperator MultiplikationsoperatorModul (Rest)-Operator

Beispiel

+

x + y gibt an, dass die Berechnung von X plus y und

-

x -y gibt die Berechnung X Subtrahieren an die Differenz von y

*

x * y bedeutet, das Produkt aus y

%

x % y bedeutet, den Rest von x dividiert durch y zu berechnen

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:

Additions- oder Verkettungsoperation und Zuweisunga += ba = a + b-=

Zuweisungsoperator, der die zusätzlichen Operationen der vier arithmetischen Operationen Addition, Subtraktion, Multiplikation und Division implementiert

Zuweisungsoperator	Erklärung	Beispiel	ist äquivalent zu
+=+=	加法运算或连接操作并赋值	a += b	a = a + b
-=	减法运算并赋值	a -= b	a= a - b
*=	乘法运算并赋值	a *= b	a = a * b
/=	除法运算并赋值	a /= b	a = a / b
%=

Subtraktionsoperation und Zuweisung

a -= b

a= a - b

*=

Multiplikationsoperation und Zuweisunga *= bDivisionsoperation und Zuweisung%=Der Beispielcode lautet wie folgt:

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

Drei: Auto-Inkrement- und Auto-Dekrement-OperatorenOperator

a = a * b		/=
a /= b	a = a / b
Modulo-Operation und -Zuweisung	a %= b	a = a % b
	Auto-Inkrement- und Auto-Dekrement-Operatoren werden verwendet. Führen Sie Inkrementierungs- (+1) und Dekrementierungsoperationen (-1) für den Wert einer Variablen durch. Die folgende Tabelle listet die in JavaScript unterstützten Inkrementierungs- und Dekrementierungsoperatoren auf:

Name

Auswirkung ++x

🎜Inkrementoperator🎜🎜erhöht x um 1 und gibt dann den Wert von x zurück🎜🎜🎜🎜x++🎜🎜Inkrementoperator🎜🎜gibt den Wert von x zurück und erhöht dann x um 1🎜 🎜🎜🎜--x🎜🎜Dekrementoperator🎜🎜dekrementiert x um 1 und gibt dann den Wert von 🎜 🎜🎜🎜🎜Der Beispielcode lautet wie folgt: 🎜

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

🎜[Verwandte Empfehlungen: 🎜Javascript-Video-Tutorial🎜, 🎜Grundlegendes Programmiervideo🎜]🎜

Das obige ist der detaillierte Inhalt vonSo implementieren Sie Additions-, Subtraktions-, Multiplikations- und Divisionsoperationen in Javascript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!