Was sind arithmetische Javascript-Operatoren?

In JavaScript sind arithmetische Operatoren Symbole, die zum Ausführen arithmetischer Operationen an Zahlen (Literal oder Variablen) verwendet werden, einschließlich: Additionsoperator „+“, Subtraktionsoperator „-“ und Multiplikationsoperator „*“, Divisionsoperator „/“, Rest Operator „%“, numerischer Negationsoperator „-“.

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

In JavaScript sind arithmetische Operatoren ein Symbol, das zum Ausführen arithmetischer Operationen an Zahlen (Literal oder Variablen) verwendet wird. Sie sind Symbole, die zum Ausführen grundlegender arithmetischer Operationen (arithmetische Operatoren) verwendet werden und zur Verarbeitung der vier arithmetischen Operationen verwendet werden.

Zu den arithmetischen Operatoren gehören: Addition +, Subtraktion -, Multiplikation *, Division /, Restoperator % und numerischer Negationsoperator -.

%Modulo-Operator (Rest)x % y bedeutet die Berechnung des Restes von Achten Sie auf die Summationsoperation von Sonderoperanden. Beispiel 2Der Additionsoperator kann basierend auf dem Datentyp der Operanden entscheiden, ob hinzugefügt oder verbunden werden soll. Bei Verwendung des Additionsoperators sollten Sie zunächst prüfen, ob der Datentyp des Operanden den Anforderungen entspricht. Subtraktionsoperator

Operator	Beschreibung	Beispiel
+	Das Addieren des Operators	x + y bedeutet die Berechnung der Summe von x plus y.
-	Subtrahieren Ionenoperator	x-y Stellt die Berechnung der Differenz dar von x minus y
*	Multiplikationsoperator	x * y Stellt die Berechnung des Produkts aus
		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
	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

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 . Negationsoperation

Der Negationsoperator ist ein unärer Operator, auch unärer Subtraktionsoperator genannt. Beispiel

Achten Sie auf die Negationsoperation spezieller Operanden.

console.log(- 5);  //返回-5。正常数值取负数
console.log(- "5");  //返回-5。先转换字符串数字为数值类型
console.log(- "a");  //返回NaN。无法完全匹配运算，返回NaN
console.log(- Infinity);  //返回-Infinity
console.log(- (- Infinity));  //返回Infinity
console.log(- NaN);  //返回NaN

Dem unären Subtraktionsoperator entspricht der unäre Additionsoperator, mit dem sich ein Wert schnell in einen numerischen Wert umwandeln lässt.

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:

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

BeispielAchten 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

【Verwandte Empfehlungen:

Javascript-Lern-Tutorial

】

Das obige ist der detaillierte Inhalt vonWas sind arithmetische Javascript-Operatoren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!