Several operators in javascript

catalogue

operator

classification

  Arithmetic operator

Assignment Operators  

Comparison operator

General comparison

Absolute comparison

Logical operator

! Non: negative

  ternary operator

operator

classification

  • Operators: arithmetic operator, assignment operator, comparison operator, logical operator, ternary operator

  • Expression: arithmetic expression, assignment expression, judgment expression, logical expression

  Arithmetic operator

+  -   *   /  % Surplus       Self increasing++     Self subtraction--

  • The data will be converted into numbers as much as possible during operation. The operation (built-in for us, which belongs to implicit conversion) conforms to the law of Number

  • +: once a string representation is encountered, the data on the other side will also be converted to a string

  •  console.log(10 + 10);
            console.log(10 + "10"); //"10" + "10" =>"1010"
            console.log(10 + 20 + "100"); //30 + "100" => "30" + "100" => "30100"
            console.log(true + 100); // 1 + 100 =>101
            console.log(false + null); // 0 + 0 => 0
            console.log("" + 100); // "" + "100" => "100"
    
            console.log(10 - "5"); // 10 - 5 = >5
            console.log(10 - "5px"); // 10 - NaN =>NaN
            console.log(10 - null); // 10 - 0 => 10
            console.log(10 - true); // 10 - 1 => 9
    
            console.log(10 * null); // 10 * 0 => 0
            console.log(10 * true); // 10 * 1 => 10
    
            console.log(100 / ""); // 100 / 0 => Infinity
    
            // %Surplus (mold taking)
            console.log(100 % "5"); //0
            console.log(100 % "3"); //1

  • ++: whether + + is in front or + + is in the back, it means to add 1 by itself, + + is in the front, it means to add 1 by itself first, and then carry out the operation, + + is in the back, it means to carry out the operation first, and then add 1 by itself

  • --: no matter -- before or -- after, it means self subtraction of 1, -- before, it means self subtraction of 1 before operation, -- after, it means operation first and then self subtraction of 1

   var a = 5;
        // a++;
        ++a;
        console.log(a);//6
        var b = 3;
        // var c = ++b;
        // console.log(c,b); //4 4

        // var c = 3;
        // console.log(c, b); //3 4
        var e = 2; //10
        //          2   +  3  +  5 + 5   +  7  -  7  -  9   + 9
        console.log(e++ + e++ + ++e + e++ + ++e - e++ - ++e + e++); //15
        console.log(e); //10
        var f = 3; //5
        //          3  +  4  +  6  -  5  - 5  +  4   -  5  -  4  +  4   + 4
        console.log(f++ + f++ + ++f - --f - f-- + f++ - f-- - f-- + ++f + f++); //6
        console.log(f); //5
        // ++-- implicit conversion also exists
        var test1 = "10";
        --test1;
        console.log(test1);//9

Assignment Operators  

=Assignment assigns the value to the right of the equal sign to the left of the equal sign
+=  -=  *=  /=  %=

var a = 10;
console.log(a);

// Add 5 on the basis of a
// Reassign a
// a = 15;
// console.log(a);

// a = a + 5;
a+=5; //Equivalent to a = a + 5;
console.log(a);


var b = 100;
b -= 50; //<=> b = b - 50;
console.log(b);

//...

Comparison operator

General comparison

==   be equal to  >  >=  <  <=   != Not equal to

 
        // 1. When comparing data, we will try to convert it into numbers for comparison (built-in to help us, which belongs to implicit conversion). It conforms to the law of Number  
        console.log(10 > 5);//true
        console.log(10 > "5");// 10 > 5 true
        console.log(true > false);//1 > 0 => true
        console.log("100px" > 100);// NaN > 100 => false
        console.log(null > "");// 0 > 0 =>false
        console.log(null >= "");// 0 > 0 =>true
        console.log(10 != "20"); //10 != 20 => true

        // 2.null is equal to undefined, but null and undefined are not equal to other data types
           //null == 0  =>false
        console.log(null == "");//false
        console.log(null == undefined);//true
        console.log(NaN == NaN);//false
       console.log(NaN != NaN);//true
       console.log(undefined == undefined); //true
       console.log(undefined == 0);  //false  
       console.log(null == undefined);//true
       console.log(4 == 'abc'); //false
       console.log(NaN == NaN);//false
       console.log(NaN != NaN);//true
       console.log(null == null); //true
       console.log(null !== undefined);//true
       console.log(3 !== "3");//true
          console.log(null >= 0);  true
            console.log(null <= 0); true
        // 3. String comparison is based on ASCII (Unicode encoded) values and is based on bits. Once a bit compares the result, it will not be compared
        console.log("158" > "1399999999999931231");//false  
        // 0 - 9 :48 - 57
        // A - Z: 65 - 90
        // a - z: 97 - 122

Absolute comparison

===Absolutely equal to   !== Absolutely not equal to

//1. Different data types must be different
 //=== Absolutely equal to   (not only the values should be equal, but also the data types should be the same)
         //   !==    10 !== "10"   10 != "10"

console.log(0 == "");
console.log(0 === "");
console.log(9 === "9");
console.log(null === undefined);
console.log("10" !== 10);//true

Logical operator

 && And  || Or   ! wrong  

  • &&And: the relationship between and indicates that all are true, talent is true, and one false is false

  • ||Or: it means that the relationship between or is false only when it is false, and true is true

  // &&And | or
        console.log(true && true); //true
        console.log(true && false && true); //false
        console.log(true || false);//true
        // The logical operator will automatically detect whether the current data type is true or false, which conforms to the rule of Boolean
        // Return the value of the corresponding position according to its own law
        // Short circuit operation  
        var res = 66 && "10" && "ha-ha" && 100;
        console.log(res);//100
        var res1 = 66 && null && "ha-ha" && 100;
        console.log(res1);//null
        var res2 = "aa" || "bb" || "";
        console.log(res2); //"aa"   
        var res3 = "" || null || undefined || NaN;
        console.log(res3);//NaN
  • ! Non: negative

// First convert the current data to Boolean value, which conforms to the law of Number, and then reverse it
console.log(!10); // true - > false
console.log(!20);//true -> false
console.log(!"ha-ha"); //true -> false
console.log(!""); //false -> true

  ternary operator

Conditions? Code segment executed when conditions are satisfied: code segment executed when conditions are not satisfied; (the ternary operator is also called question mark and colon expression, which is generally used for simple judgment, equivalent to if..else)

// Conditions? Code segment executed when conditions are satisfied: code segment executed when conditions are not satisfied; (the ternary operator is also called question mark and colon expression, which is generally used for simple judgment, equivalent to if..else)
        // If the condition is true, the code segment after the question mark will be executed; if the condition is false, the code segment after the colon will be executed
        var score = 50;
        score >= 60 ? console.log("Have something good for lunch") : console.log("Not at noon~~~");

        // Single data will automatically detect true and false  
        "" ? console.log("really"): console.log("false");

Tags: Javascript

Posted on Wed, 20 Oct 2021 14:01:51 -0400 by chuddyuk