Let’s talk about JavaScript operators

Operator, also known as operator, is a symbol used to implement functions such as assignment, comparison, and performing arithmetic operations.

Commonly used operators in JavaScript are:

• Arithmetic operators
• Increment and decrement operators
• Comparison
• operators Logical operators
• Assignment operators

Arithmetic operator

concept: Symbols used in arithmetic operations, used to perform arithmetic operations on two variables or values.

console. log(1 + 1); //2
    console.log(1 - 1); //0
    console.log(1 * 1); //1
    console.log(1 / 1); //1
    console.log(4 % 2); //0

floating point numbers will have errors in arithmetic operations (avoid direct participation in calculations):

console.log(0.1 + 0.2); //0.30000000000000004

cannot directly determine whether two floating point numbers are equal.

var num = 0.1 + 0.2;
    console.log(num == 0.3); //false

• Arithmetic operator priority: multiplication and division first, addition and subtraction.
• You can use the % remainder operator to determine whether a number is divisible.

Expression and return value:

composed of numbers and operators A formula composed of , variables, etc. is called an expression.

The expression will eventually return a result to us, which is called the return value.

Increment and Decrement Operators

If you need to repeatedly add or subtract 1 to a numeric variable, you can use the increment ( ++ ) and decrement ( -- ) operators to accomplish this.

Complicated writing:

var num = 1;
    num = num + 1;
    num = num + 1;
    console.log(num); //3

prefix increment operator:

++ is written in front of the variable

++num prefix increment is to increase by 1, similar to num=num+1

var age = 10;
    ++age;
    console.log(age);//11 Similar to the usage formula of age = age + 1

: add it first, then return the value

console.log(age);
    var a = 10;
    console.log(++a + 10); //(10+1)+10=21

post-increment operator

++ is written after the variable

num++ post-increment, which means adding 1 to itself, similar to num=num+1

var age = 10;
    age++;
    console.log(age);//11 is similar to

the usage formula of age = age + 1: return the original value first, then add

var a = 10;
    console.log(a++ + 10); //10+10=20
    console.log(a); //11

Summary of differences

• The pre-increment and post-increment operators can simplify the writing of code, making the value of a variable +1 simpler than before.
• When used alone, the results are the same.
• When used in conjunction with other codes, the execution results will be different.
• Preposition: add self first, then perform calculations ( first oneself before others )
• Postposition: first perform calculation on original value, then add oneself ( first one first, then oneself )
• When developing, most of the time, postfix increment/decrement is used, and the code occupies one line. Example: num++;

Exercise:

var e = 10;
    var f = e++ + ++e; //1.e++=10 e=11 2.++e=12 f=10+12
    console.log(f); //22

Comparison operator

concept: Comparison operator (relational operator) is an operator used when comparing two data . After comparison operation, a Boolean value (true/false) will be returned. As the result of a comparison operation.

console.log( 2 <= 5); //true
    console.log('Yue Zeyi' = 'personal blog'); //false
    console.log(17 == '17'); //true default conversion data type, string type is converted to numeric type console.log(17 = '17'); //false data type is different, value and data type are required

consistent

Logical operator

concept : Logical operators are used Operators that perform Boolean operations also return a Boolean value. It is often used to judge multiple conditions in later development.

logical AND

Symbol: && is true when both sides of and

true true . As long as one side is false , the result is false

console.log(3 > 5 && 3 > 2); //false
    console.log(3 < 5 && 3 < 7); //true

logical OR

symbol: || is equivalent to if

both sides of or are false , the result is false , as long as one side is true , the result is true

console.log(3 > 5 && 3 > 2); //false
    console.log(3 < 5 && 3 < 7); //true

logical negation

symbol: ! Relative to not,

logical negation is also called the negation symbol, which is used to obtain the opposite value of a Boolean value.

console.log(!true); //false
    console.log(!false); //true

short-circuit operation (logical interruption)

The principle of short-circuit operation: when there are multiple expressions (values), when the expression value on the left can determine the result, the expression on the right will no longer continue to be operated. The value of the formula.

Logical AND:

• Syntax :表达式1 && 表达式2
• If the first expression evaluates to true, then returns expression 2.
• If the first expression evaluates to false, returns expression 1

console.log(123 && 456); //Returns 456, all numbers except 0 are true.
    console.log(123 && 456 && 789); //Return 789, push back in sequence console.log(0 && 456); //0

logical OR:

• syntax :表达式1 || 表达式2
• if the result of expression 1 is If true, expression 1 is returned.
• If expression 1 is false, expression 2 is returned.

console.log(123 || 456); //123
    console.log(123 || 456 || 123 + 456); //123
    console.log(0 || 456 || 123 + 456); //456

Note: Logical interruption will cause a short-circuit operation, that is, the subsequent code will not be executed, affecting the programmer's running results.

varnum = 0;
    console.log(123 || num++); //Logical interruption caused num++ not to be executed console.log(num); //0

Assignment operator

concept : operator used to assign data to variables Assignment

var num = 5;
    num += 10;
    console.log(num); //5+10=15
    num *= 3;
    console.log(num); //15*3=45

operator priority precedence

• the logical non-priority in the unary operator is very high.
• Logical AND has higher priority than logical OR

console.log(4 >= 6 || 'I' != 'you' && !(12 * 2 == 144) && true); //true
    /* 
    Logical operators are divided into four sections 1.4 >= 6 to get false
    2.'I' != 'you' must be true
    3.!(12 * 2 == 144) gets true
    4.true
    Then judge the logical AND: 2 and 3 are true, 3 and 4 are true 
    Then judge the logical or: true
     */