Introduction to operator types and rules in JavaScript_Basic knowledge

There are many operators in JavaScript, mainly divided into arithmetic operators, identity operators, comparison operators, string operators, logical operators, assignment operators, etc. These operators have some own operation rules. Let’s introduce the operators in JavaScript to you.

　1. Types of JavaScript operators

　1. Arithmetic operators: , - , * , / , % , -(unary negation) , , --

2. Identity operators: ==, ===, !==, !===

3. Comparison operators: , =

4. String operators: , =, =,

5. Logical operators: &&, ||, !,

6. Assignment operators: =, =, *=, -=, /=

　 2. Rules of JavaScript operators

1. Arithmetic operator rules

　" ": "Addition" and "Connection" operations can be performed; if one of the two operators is a string, JavaScript will convert the other into a string, and then connect the two operands.

　" ": If an operand is an object, JavaScript will convert the object into a number for addition or a string for concatenation;

　"-""*""/" if If one of the two operands is a non-number, it is converted into a number to perform mathematical operations.

　“/” In JavaScript, since all numbers are floating point numbers, the results of division are all floating point numbers, 5 / 2 = 2.5; the result of dividing by 0 is plus or minus infinity; 0/0 is NaN;

"%" modulo operator: Calculates the modulo of the first operand to the second operand, that is, when the first operand is divided by the second operand, the remainder is returned. If the operand is non-numeric, it is converted to a number.

“-” unary negation: negate the operand. If the operand is not a number, convert it into a number.

　""--" Increment operator/decrement operator symbol: The operand must be a variable, an element of a tree group, or an attribute of an object. If the operand is not a number, it is converted to a number.

Note: If " " is located before the operand, increment the operand first, and then calculate the value after the increment of the operand.

If "--" is located after the operand, first calculate the value before the operand is incremented, and then increment the operand.

　For example: i = 1; //Assign the value 1 to i

　 j = i; //First increment i to 2, then assign 2 to j, the value of i is 2, the value of j is also 2.

　i = 1; //Assign i a value of 1

　j = i; //First assign i to j, and then increment i to 2. The value of i is 2. The value of j is 1.

The decrement operator "--" is the same as " ".

2. Equality operator and identity operator

(I) “==” “!==” Equality operator and non-identity operator:

Comparison 2 operands, returns a non-Boolean value.

Comparing numerical values, strings, and Boolean values ​​all use quantitative values. Two variables are equal if and only if the values ​​stored in them are equal.

When comparing objects, arrays, and functions, references are used. Two variables are equal only when they refer to the same object. Two different arrays are completely different, even if they have exactly the same elements. For variables that store references to objects, arrays, and functions, they are equal only when they refer to the same object, array, or function.

Attention! Principles that should be followed:

When the types of the two operands are different: convert them into the same type,

1) A number and a character String, after converting the string into a number, compare.

2) true is converted to 1 and false is converted to 0 for comparison.

　3) An object, array, function and a number or string. The object, array, or function is converted into a primitive type value and then compared. (Use valueOf first, and if that doesn’t work, use toString)

4) Other types of combinations are not equal.

If the two operand types are the same, or after conversion to the same type:

1) Two strings: If the characters at the same position are equal, the two strings are the same.

2) Two numbers: If the two numbers are the same, they are the same. Not the same if one is NaN, or if both are NaN.

3) If both are true, or if both are false, it means the same thing.

4) If two references refer to the same object, function, or array, they are equal. If they refer to different objects, functions, or arrays, they are not the same. Even if these two objects, functions, and arrays refer to Can be converted to an exact equivalent of the original value.

5) 2 nulls, or both are undefined, then they are equal.

　“!=” Non-Equality Operator: The result is opposite to the result of equality operator detection.

(II) "===" "!===" identity operator and non-identity operator symbols:

The identity operator follows the comparison rules of the equality operator, but It does not perform type conversion on the operands. When the types of the two operands are different, false is returned; only when the types of the two operands are the same, the comparison rules of the equality operator are followed.

The "!==" non-identical operator has the opposite result than the identical operator. Returns true if the types or values ​​of the two operands are different.

3. Comparison operators

These comparison operators are used to compare values ​​of different types, and the result returns a Boolean value.

　“”“=”

　 Note the rules: The operands of the comparison can be of any type, but they can only be performed on numbers and operands. Operands that are not numbers and strings are converted to numbers or strings.

1) If both operands are numbers, or both can be converted to numbers, the comparison will be based on the size of the numbers;

2) If both operands are strings, Or they can be converted into strings, and they will be compared in alphabetical order;

　3) If the string encounters a number, the string will be converted into a number for comparison.

　4) If the operand cannot be converted into a number or a string, the result is false.

4. String operators

There are no dedicated string operators, but some operators behave differently when encountering string operands.

　(I)“ ” concatenates 2 strings;

　1) When both operands are strings, concatenate them;

　2) When among them When one of them is a number, convert the numbers into strings and connect them; Comparison operators such as

(II)">" confirm the order of the two strings through comparison, and the comparison uses the order of characters. The smaller ones go before the larger letters, and the uppercase letters go before the lowercase letters.

　 (III) The action method of " " depends on the calculation order,

　 For example: s = 1 2 "var" then: return the result 3var; because 1 2 is calculated first, and then the result 3 Convert it into a string and connect it with "var";

For example: s = "var" 1 2 then: return the result var12; because the connection between var and 1 is calculated first, and then the result var1 is converted into a string 2 are connected.

5. Logical operators

are used to perform Boolean operations and are often used together with comparison operators to express complex comparison operations.

　 “&&” logical AND operation, “||” logical OR operator, “!” logical NOT operator

(I) “&&” when both operands are Boolean values When, the logical AND operation is performed on them, that is: if and only if both Boolean values ​​are true, the result is true, otherwise it is returned false.

Note: Actual performance

"&&" will detect the Boolean value of the first expression operand. If the first operand expression returns false, the first operand on the left will be returned. The value of the expression: false; otherwise, the second operand expression on the right will continue to be detected, and then the value of the second operand expression will be returned;

For example: if (a = b) stop( ); Equivalent to (a = b) && stop();

This method is deprecated because the code on the right side of the operator is not guaranteed to be executed,

For example: if (( a
It will be simpler and safer to regard "&&" as a Boolean algebra operator.

　(II) "||" When both operands are Boolean values, logical OR performs an OR operation on them, that is: when one of the two Boolean values ​​is true, the result is true. , otherwise return false.

Note: Actual performance

"||" will detect the Boolean value of the first expression operand. If the first operand expression returns true, the first operation on the left will be returned. The value of the number expression: true; otherwise, the second operand expression on the right will continue to be detected, and then the value of the second operand expression will be returned;

This method is also deprecated because the operation The code on the right side of the symbol is not guaranteed to be executed.

It is generally opposed to using expressions with other functions (assignments, function calls, increments and decrements) on the right side of ||;

Replace "| |" is considered as a Boolean algebra operator, which is simpler and safer.

(III) "!" Logical negation is a unary operator, placed before the operand, and its purpose is to negate the operand.

6. Assignment operator

(I) "=" is the assignment operator; it always expects the operand on the left to be a variable, an element of an array, or an attribute of an object;

Expect the right-hand side to be an arbitrary value of any type;

Right-to-left associativity. If there are multiple assignment operators in an expression, calculation starts from the rightmost one.

Note: Each assignment expression has a value, which is the value on the right side of the operator;

(II) You can use the assignment operation with operation

“=" The value on the left is added to the value on the right and assigned to the value on the left. "-=" "/=" "*=" has the same method;

7. Other operators

"?:" conditional operator is the only ternary operator;

The Boolean result of an expression? Expression 1 (any value of any type): Expression 2 (any value of any type);

Based on the Boolean result of the first operand, If it is true, the second operand expression is executed and the value of the second operand expression is returned; if the Boolean result of the first operand is false, the third operand expression is executed and the value of the second operand expression is returned. The value of the three operand expression.

　3. Notes on JavaScript operators

　1. Pay attention to the data type passed to the operator and the data type returned! Different operators expect it An operand expression evaluates to a result that conforms to a data type.

For example: string multiplication cannot be performed, "a" * "b" is illegal, but when possible, javascript will convert the expression into the correct type, so , the expression "3" * "5" is legal. JavaScript converts the string into a number and performs the operation. The result is the number 15, not the string "15".

2. Different performances depending on the operands:

String string = string (connected); "a" "b" = "ab" "5" "6" = "11"

　 String number = (string converted to number) string (concatenated); "a" 5 = "a5" 5 is converted to string "1" 0 = "10"

　Number number = number (addition) 5 5 = 10.

3. Pay attention to the associativity of operators. Some operators are associative from left to right; some are associative from right to left.

　For example: w = a b c is equivalent to w = (a b) c;

　w = ---b is equivalent to w = - ( - ( -b ) ); w = a = b = c is equivalent to w= ( a = ( b = c ))

The associativity of unary operators, assignment operators, and ternary operators is from right to left;

JavaScript This is the introduction of the operators here, I hope it will be helpful to you in your daily life.