Detailed explanation of the definition and usage of arithmetic expressions in the JavaScript basic course

The basic arithmetic operators are *, /, %, +, -. Except for + addition, other operators are very simple. They just convert the operators into numbers when necessary, and then calculate the product, quotient, remainder (modulus) and difference. All those operations that cannot be converted to numbers will be converted to NaN values. If the operand (or conversion result) is a NaN value, the result of the arithmetic operation is also NaN

The operator "/" divides the second operand by the first operand, if you have used those to distinguish integers and floating-point programming languages. Then when dividing an integer by an integer, the desired result is also an integer. All numbers in JavaScript are of floating point type, and the results of division operations are also of floating point type. For example, the result of 5/2 is 2.5, not 2. The result of an operation that divides by 0 is positive infinity or negative infinity. And the result of 0/0 is NaN. All these operations are error-free.

The operator "%" calculates the modulus of the first operand to the second operand. In other words, it is the remainder of the first operand divided by the second operand. The sign of the result remains the same as the sign of the first operand (the dividend). For example, the result of 5%2 is 1, and the result of -5%2 is -1.

The operands of the remainder operator are usually integers, but they also work with floating point numbers. 6.5%2.1 turns out to be 0.2. (0.19999999999999973)

i. "+" operator

The binary addition operator "+" can add two numbers and can also perform string concatenation operations:

1+2 //=> 3
"hello" + "" + "there" // =>"hello there"
"1"+"2" //=>"12"

When both operands are numbers or strings, the calculation result is obvious. However, for other cases, some necessary type conversions must be performed. And the behavior of the operator depends on the result of the type conversion. Technically speaking, the behavior of the addition operator is as follows:

If an operand is an object, the object will be converted into a primitive class value following the conversion rules of objects to primitive values ​​(refer to Chapter 3, Section 8, Section 3) . Dates are converted by the toString() method of objects, and other objects are converted by the valueOf() method (if the valueOf() method returns a primitive value). Since most objects do not have a valueOf() method available, they will perform capture and replacement through the toString() method.
After converting the object to the original value, if one of the operands is a string, the other An operand is also converted to a string. Then perform string concatenation.
Otherwise, both operands will be converted to numbers (or NaN), and then the addition operation will be performed.
Here are some examples

1 + 2 //=>3 加法
"1" + "2" //=>"12" 字符串连接
"1" + 2 //=>"12"数字转换为字符串后进行字符串连接
1 + {} //=>"1[object object]":对象转换为字符串后进行字符串连接
true + true //=>2 布尔值转换为数字后做加法
2 + null //=>2 null转换为0后做加法
2 + undefined //=>NaN undefined转换为NaN做加法

Finally, something special to note. When the addition operation is used with strings, the effect of addition on the order of operations must be considered. That is to say, the result of the operation depends on the order of operations of the operators, such as

1 + 2 + "bmice" //=> "3 bmice"
1 + (2 + "bmice") => "12bmice"

ii. Unary operator

The unary operator acts on a single operand. and produce a new value. In JavaScript, unary operators have high precedence and are right-associative. This section describes the unary operators (+, -, ++ and --), which convert operations to numbers when necessary. It should be noted that + - is a unary operator and a binary operator,

unary addition +

The unary addition operator converts the operand number into a number (or NaN), and Return this converted number. If the operand itself is a number, this number is returned directly.

Unary subtraction-

When - sign is used as a unary operator, it will convert the operand into a number as needed, and then change the sign of the operation result,

increment + +

The increment "++" operator performs an increment (+1) operation on its operand, which is an lvalue (variable, array element or object attribute). Operators convert operands to numbers. Then add 1 to the number, and reassign the added value to a variable, array element, or object property.

The return value of the increment++ operation depends on the position of its operands.

When the operator precedes the operand, it is called the "pre-increment" operator. It performs incremental calculations on the operand and returns the calculated value.

When the operator is after the operand, it is called a "post-increment" operator. It performs incremental calculation on the operand, but returns an unincremented value. . Such as

      var i = 1,j = ++i //The values ​​​​of i and j are both 2
      var i = 1,j = i++; //i is 2, j is 1
It should be noted that just like ++x and the sum x=x+1, the "++" operator never performs string concatenation, it always converts the operand to a number and increments it by 1. If x is the string "1", the result of ++x is the number 2, and x+1 is the string "11"

The operation method of decrement and increment is the same, it converts the operand into an array, Then subtract 1.

iii.Bitwise operator

Bitwise operators can perform lower-level bitwise operations on binary data represented by numbers. Although they are not traditional pure mathematical operations, they are classified here as arithmetic operators because they operate on numeric types and return numbers.

The above is the detailed content of Detailed explanation of the definition and usage of arithmetic expressions in the JavaScript basic course. For more information, please follow other related articles on the PHP Chinese website!