Javascript Basics: Detailed Explanation of Operators and Flow Control

  //alert(1 + 1);
        console.log(1 + 1); // Type spaces on both sides of the operator //alert(1 - 1); //0
        //alert(1 * 1); //1
        //alert(1 / 1); //1

//alert(4 % 2); //0
 //alert(5 % 3); //2
//alert(3 % 5); //3 Attention! ! ! ! ! ! ! ! ! !

  var result = 0.1 + 0.2; // The result is not 0.3, but: 0.30000000000000004
  console.log(0.07 * 100); // The result is not 7, but: 7.000000000000001

 var num = 0.1 + 0.2;
 alert(num == 0.3); //false To convert to binary, there will be errors in accuracy

 <script>
        //1. Want a variable to add 1 num=num+1, which is troublesome var num = 1;
        num = num + 1; // ++num
        num = num + 1;
        //alert(num); //3
        //2. Prefix the increment operator ++ before the variable var age = 20;
        ++age; //similar to age = age + 1
        //alert(age); //21
        // 3. Add 1 first and then return the value var p = 10;
        alert(++p + 10); //21
    </script>

 <script>
        var num = 10;
        num++; // num = num + 1 ++num
        // alert(num); //11
        //1. If the pre-increment and post-increment are used separately, the effect is the same //2. Post-increment formula: return the original value first and then add 1
        var age = 10;
        //alert(age++ + 10); //20
        //alert(age); //11
        //alert(age + 10); //21
    </script>

 <script>
        var a = 10;
        ++a; //++a = 11 a=11 ++a is an expression var b = ++a + 2; // a=12 a++ = 12 Prefix: first add itself, then return the value //alert(b); //14  
        var c = 10;
        c++; //c++ = 11 c = 11
        var d = c++ + 2; //c++ = 11 c = 12 Postposition: return the original value first, then add it //alert(d); //13
        var e = 10;
        var f = e++ + ++e; // e++ =10 e=11 ++e=12
        console.log(f); //22
        // Post-increment expression returns the original value and then increments the variable by 1
        // Prefix increment first, then operation // Used alone, the running results are the same // When developing, most people use postfix increment/decrement, and the code occupies a single line, for example: num++; or num--
 </script>

<script>
        // alert(3 >= 5); //false
        // alert(2 <= 5); //true
        //1. The equal symbol in our programmers is ==. The default conversion data type will convert string data to numeric type. //Only the value is required to be relative. //alert(3 == 5); //false
        //alert('pink teacher' == 'Andy Lau'); //false 
        //alert(18 == 18); //true
        //alert(18 == '18'); //true
        //alert(18 != 18); //false != not equal //2. Among us programmers, we have the requirement that the values ​​on both sides are exactly the same, and the data types must be exactly the same for it to be true
        //alert(18 === 18); //true
        //alert(18 === '18'); //false 
</script> 

 <script>
        // 1. Logical AND && (and) The result is true if both sides are true. As long as one side is false, the result is false
        //alert(3 > 5 && 3 > 2); //false
        //alert(3 < 5 && 3 > 2); //true
        // 2. Logical or || (or) If both sides are false, the result is false. As long as one side is true, the result is true.
        //alert(3 > 5 || 3 > 2); //true
        //alert(3 > 5 || 3 < 2); //false
        //3. Logical negation! (not)
        alert(!true); //false
    </script>

   <script>
        var num = 7;
        var str = "I love you~China~";
        alert(num > 5 && str.length >= num); //true
        alert(num < 5 && str.length >= num); //false
        alert(!(num < 10)); //false
        alert(!(num < 10 || str.length == num)); //false
    </script>

  3. Logical AND short-circuit operation If expression 1 is true, then expression 2 is returned. If expression 1 is false, then expression 1 is returned.
        alert(123 && 456); //456 Except for 0, all numbers are true alert(0 && 456); // 0
        alert(0 && 1 + 2 && 456 * 56789); // 0
        alert('' && 1 + 2 && 456 * 56789); // ''
        If any is empty or negated it is false, the rest are true: 0 '' null undefined NaN

 4. Logical or short-circuit operation If expression 1 is true, expression 1 is returned. If expression 1 is false, expression 2 is returned.
        alert(123 || 456); // 123
        alert(123 || 456 || 456 + 123); // 123
        alert(0 || 456 || 456 + 123); // 456

Logical interruption is very important, it will affect the results of our program var num = 0;
        //alert(123 || num++); //123 num++ will not run //alert(num); // 0

  <script>
        var num = 10;
        // num = num + 1; //num++
        // num = num + 2 //num+=2;
        var num = 10;
        num += 5;
        // alert(num); //15
        var num = 10;
        num -= 5;
        // alert(num); //5
        var age = 2;
        age *= 3;
        // alert(age); //6
        var age = 6;
        age /= 3;
        // alert(age); //2
        var age = 4;
        age%= 2;
        // alert(age); //0
    </script>

  <script>
        // Unary operator: ++num !num Binary operator: 2 + 3
        // Exercise 1
        console.log(4 >= 6 || '人' != 'Avatar' && !(12 * 2 == 144) && true) //true
        var num = 10;
        console.log(5 == num / 2 && (2 + 2 * num).toString() === '22'); //true
        console.log('-------------------');
        // Exercise 2
        var a = 3 > 5 && 2 < 7 && 3 == 4;
        console.log(a); //false
        var b = 3 <= 4 || 3 > 1 || 3 != 2;
        console.log(b); //true
        var c = 2 === "2";
        console.log(c); //false
        var d = !c || b && a;
        console.log(d); //true
    </script>

        if (conditional expression) {
            //Execute statement}
        2. Execution idea If the result of the conditional expression in if is true, the execution statement in the curly braces is executed. If the result of the if conditional expression is false, the statement in the curly braces is not executed, and the code after the if statement is executed. 3. Experience code:
        if (3 < 5) {
            alert('Desert Camel');
        }

  <script>
        // Pop up the prompt input box, the user enters the age, the program takes this value and saves it in the variable // Use the if statement to determine the age. If the age is greater than 18, execute the output statement in the if brackets var age = prompt('Please enter your age');
        if (age >= 18) {
            alert('You can enter the Internet cafe')
        }
    </script>

<script>
        // 1. Syntax structure if else // if (conditional expression) {
        // // Execute statement 1
        // } else {
        // // Execute statement 2 
        // }
        // 2. Execution idea If the expression result is true, then execute statement 1, otherwise execute statement 2
        // 3. Code verification var age = prompt('Please enter your age:');
        if (age >= 18) {
            alert('I want to take you to the Internet cafe to steal headphones');
        } else {
            alert('Go away and do your homework');
        }
        // 5. Only one of the statements 1 in if and 2 in else can be executed.
        // 6. else is followed directly by curly braces</script>

  // Algorithm: A leap year is divisible by 4 and not by 100 (e.g. 2004 is a leap year, 1901 is not a leap year) or a leap year is divisible by 400 // Pop up a prompt input box, let the user enter the year, take the value and save it in a variable // Use an if statement to determine whether it is a leap year. If it is a leap year, execute the output statement in the if braces, otherwise execute the output statement in the else braces // Be sure to pay attention to the writing of && and or ||, and also note that the method of judging whether it is divisible is to take the remainder as 0
         var year = prompt("Please enter the year to be tested:")
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            alert(year + 'is a leap year')
        } else {
            alert(year + 'is a normal year')
        }

<script>
        // 1. A multi-branch statement is a process of using multiple conditions to select different statements to execute and get different results. // 2. It is a multi-branch statement // 3. Syntax specification if else if statement if (conditional expression 1) {
            //Statement 1;
        } else if (conditional expression 2) {
            //Statement 2;
        } else if (conditional expression 3) {
            //Statement 3;
        } else {
            //Last statement;
        }
        // 4. Execution ideas // If conditional expression 1 is satisfied, execute statement 1. After execution, exit the entire if branch statement // If conditional expression 1 is not satisfied, determine if conditional expression 2 is satisfied, and execute statement 2. And so on // If all the above conditional expressions are not true, execute the statements in else // 5. Points to note // (1) Multiple branch statements or multiple choice 1. Only one statement can be executed in the end // (2) Theoretically, there can be any number of conditions in else if // (3) There is a space in the middle of else if</script>

    <script>
        // Pseudocode follows the idea of ​​judging from large to small // Pop up a prompt input box and let the user enter the score (score), and save this value in a variable // Use multi-branch if else if statements to judge and output different values ​​var score = prompt('Please enter a score:');
        if (score >= 90) {
            alert('A');
        } else if (score >= 80) { //No need to write: 90>score>=80 to run the following, it must be less than 90 alert('B');
        } else if (score >= 70) {
            alert('C');
        } else if (score >= 60) {
            alert('D');
        } else {
            alert('E'); //Quotes are required, otherwise it will be considered a variable and needs to be declared.}
    </script>

<script>
        // 1. The expression composed of ternary operators is called a ternary expression // 2. Unary operator: ++num Binary operator: 3 + 5 Ternary operator: ? :
        // 3. Syntax structure // Conditional expression? Expression 1: Expression 2
        // 4. Execution ideas // If the conditional expression is true, return the value of expression 1. If the conditional expression is false, return the value of expression 2. // 5. Code experience var num = 10;
        var result = num > 8 ? 'Yes' : 'No' // We know that the expression has a return value, assign it to result 
        console.log(result); //Yes//Equivalent to:
        var num = 10;
        if (num > 5) {
            alert('Yes');
        } else {
            alert('No');
        }
        // Ternary expression is a simplified version of if else
    </script>

   <script>
        // User inputs a number between 0 and 59 // If the number is less than 10, add 0 in front of the number (add 0 for concatenation) otherwise no operation is performed // Use a variable to receive this return value and output var num = prompt('Please enter a number between 0 and 59?')
            //Ternary expression: expression? Expression 1: Expression 2;
        var result = num < 10 ? '0' + num : num; //Character type 0 Assign the return value to a variable alert(result);
    </script>

    <script>
        //1. The switch statement is also a multi-branch statement and can also implement multiple selections 1
        // 2. Syntax structure switch conversion, switch case small example or option meaning break exit /* switch (expression) {
                case value1: execute statement 1; break;
                case value2: execute statement 2; break;
                case value3: execute statement 3; break;
                default: execute the last statement;
            } */
        // 3. Execution idea: Use the value of our expression to match the option value after case. If it matches, execute the statement in the case. If it does not match, execute the statement in default. switch (2) {
            case 1: alert('This is 1'); break;
            case 2: alert('This is 2'); break; //This is 2
            case 3: alert('This is 3'); break;
            default: alert('No matching results');
        }
    </script>

        var num=1;
        switch(num){
            case 1: console.log(1);break; //1
            case 2: console.log(2);break;
            case 3: console.log(3);break;
        }
        // 1. When we develop expressions, we often write them as variables // 2. When the value of num matches the value in case, they are identical. The value and data type must be consistent. num === 1

  var num=1;
        switch(num){
            case 1: console.log(1);//1
            case 2: console.log(2);//2
            case 3: console.log(3);//3
        }

<script>
        // Pop up a prompt input box, let the user enter the name of the fruit, and save the value into a variable.
        // Use this variable as the expression inside the switch brackets.
        // Write several different fruit names in the value after case. Note that you must add quotation marks because it must be an exact match.
        // Just pop up different prices. Also note that break is added after each case to exit the switch statement.
        // Set default to no such fruit.
        var fruit = prompt('Please enter the name of the fruit')
        switch (fruit) {
            case 'apple':
                alert('The price of apples is 3.5/catties');
                break;
            case 'Durian':
                alert('The price of durian is 35/catties');
                break;
            default:
                alert('There is no such fruit');
        }
    </script>