what are javascript arithmetic operators

In JavaScript, arithmetic operators are symbols used to perform arithmetic operations on numbers (literal or variables), including: addition operator " ", subtraction operator "-", and multiplication operator "*", division operator "/", remainder operator "%", numerical negation operator "-".

The operating environment of this tutorial: windows7 system, javascript version 1.8.5, Dell G3 computer.

In JavaScript, arithmetic operators are a symbol used to perform arithmetic operations on numbers (literal or variables); they are symbols that complete basic arithmetic operations (arithmetic operators) and are used to process the four arithmetic operations. symbol.

Arithmetic operators include: addition, subtraction -, multiplication *, division /, remainder operator %, and numerical negation operator -.

Operator	Description	Example
	Addition Operator	x y means calculating the sum of x plus y
-	Subtraction operator	x - y means calculating x Subtract the difference of y
*	Multiplication operator	x * y means to calculate the product of x times y
/	Division operator	x / y means calculating the quotient of x divided by y
%	Modulo (remainder) operator	x % y means to calculate the remainder of x divided by y

Addition operator

Example 1

Pay attention to the summation operation of special operands.

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

Example 2

The addition operator can decide whether to add or connect based on the data type of the operands.

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

When using the addition operator, you should first check whether the data type of the operand meets the requirements.

Subtraction operator

Example 1

Pay attention to the subtraction operation of special operands.

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

Example 2

In the subtraction operation, if the operand is a string, try to convert it to a numerical value before performing the operation. If one of the operands is not a number, NaN is returned.

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

Use value minus 0 to quickly convert a value to a number. For example, query strings in HTTP requests are generally string numbers. You can first subtract 0 from these parameter values ​​to convert them into numerical values. This has the same result as calling the parseFloat() method, but the subtraction is more efficient and faster. Implicit conversions with the subtraction operator return NaN if they fail, which is different from the return value when performing the conversion using the parseFloat() method.

For example, for the string "100aaa", the parseFloat() method can parse out the first few numbers, but for the subtraction operator, it must be a complete number before it can be converted.

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

For Boolean values, the parseFloat() method can convert true to 1 and false to 0, while the subtraction operator treats it as NaN.

For objects, the parseFloat() method will try to call the object's toString() method for conversion, while the subtraction operator first tries to call the object's valueOf() method for conversion, and then calls toString() after failure. Make the conversion.

Negation operation

The negation operator is a unary operator, also called a unary subtraction operator.

Example

Pay attention to the negation operation of special operands.

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

Corresponding to the unary subtraction operator is the unary addition operator, which can be used to quickly convert a value into a numerical value.

Multiplication operator

Pay attention to the multiplication operation of special operands.

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

Division operator

Pay attention to the division operation of special operands.

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，解释同上

Remainder operator

Remainder operation is also called modular operation. For example:

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

Modular operation is mainly for integers. The operation also works on floating point numbers. For example:

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

Example

Pay attention to the remainder operation of special operands.

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

【Related recommendations: javascript learning tutorial】

The above is the detailed content of what are javascript arithmetic operators. For more information, please follow other related articles on the PHP Chinese website!