//alert(1 + 1);
        console.log(1 + 1);  //運(yùn)算符的左右兩側(cè)都要敲空格
        //alert(1 - 1);         //0
        //alert(1 * 1);         //1
        //alert(1 / 1);         //1

//alert(4 % 2);           //0
 //alert(5 % 3);           //2
//alert(3 % 5);           //3  注意?。。。。。。。。?！

  var result = 0.1 + 0.2;    // 結(jié)果不是 0.3，而是：0.30000000000000004
  console.log(0.07 * 100);   // 結(jié)果不是 7，  而是：7.000000000000001

 var num = 0.1 + 0.2;
 alert(num == 0.3);          //false   要轉(zhuǎn)化為2進(jìn)制，精確度會(huì)有誤差

 <script>
        //1. 想要一個(gè)變量自己加1   num=num+1 比較麻煩
        var num = 1;
        num = num + 1; // ++num
        num = num + 1;
        //alert(num);  //3
        //2. 前置遞增運(yùn)算符  ++寫在變量前面
        var age = 20;
        ++age; //類似于 age = age + 1
        //alert(age);  //21
        // 3. 先加1 后返回值
        var p = 10;
        alert(++p + 10); //21
    </script>

 <script>
        var num = 10;
        num++; // num = num + 1  ++num
        // alert(num);         //11
        //1. 前置自增和后置自增如果單獨(dú)使用  效果是一樣的
        //2. 后置自增 口訣：先返回值原值  后自加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 是表達(dá)式
        var b = ++a + 2; // a=12    a++ = 12        前置：先自加，后返回值
        //alert(b);   //14  
        var c = 10;
        c++; //c++ = 11  c = 11
        var d = c++ + 2; //c++ = 11  c = 12      后置：先原值返回，后自加
        //alert(d);                 //13
        var e = 10;
        var f = e++ + ++e; // e++ =10  e=11  ++e=12
        console.log(f); //22
        // 后置自增  先表達(dá)式返回原值  后面變量再自加1
        // 前置自增  先自加，后運(yùn)算
        // 單獨(dú)使用 ，運(yùn)行結(jié)果相同
        // 開發(fā)時(shí)，大多數(shù)使用后置遞增/減，并且代碼獨(dú)占一行，例如：num++;或者num--
 </script>

<script>
        // alert(3 >= 5);  //false
        // alert(2 <= 5);     //true
        //1. 我們程序員里面的等于符號(hào)是 == 默認(rèn)轉(zhuǎn)換數(shù)據(jù)類型 會(huì)把字符串型的數(shù)據(jù)轉(zhuǎn)換為數(shù)字型
        // 只要求值相對(duì)
        //alert(3 == 5);                     //false
        //alert('pink老師' == '劉德華');       //false 
        //alert(18 == 18);                    //true
        //alert(18 == '18');                  //true
        //alert(18 != 18);                    //false   !=  不等于
        //2. 我們程序員里面有全等 一模一樣   要求兩側(cè)的值，還有數(shù)據(jù)類型完全一致才可以 true
        //alert(18 === 18);             //true
        //alert(18 === '18');           //false 
</script>

 <script>
        // 1. 邏輯 與&&(and)  兩側(cè)都為true 結(jié)果才是true 只要一側(cè)結(jié)果為false  結(jié)果就為false
        //alert(3 > 5 && 3 > 2);   //false
        //alert(3 < 5 && 3 > 2);     //true
        // 2. 邏輯或|| （or）   兩側(cè)都為 false  結(jié)果才是假 false ,只要一側(cè)為true ,結(jié)果就是true
        //alert(3 > 5 || 3 > 2);    //true
        //alert(3 > 5 || 3 < 2);    //false
        //3. 邏輯非 ! (not)
        alert(!true); //false
    </script>

   <script>
        var num = 7;
        var str = "我愛你~中國(guó)~";
        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. 邏輯與短路運(yùn)算  如果表達(dá)式1 結(jié)果為真 則返回表達(dá)式2  如果表達(dá)式1為假 那么返回表達(dá)式1
        alert(123 && 456);              //456   除了0之外，所有的數(shù)字都為真
        alert(0 && 456);                // 0
        alert(0 && 1 + 2 && 456 * 56789); // 0
        alert('' && 1 + 2 && 456 * 56789); // ''
        如果有空的或者否定的為假 其余是真的    :  0  ''  null undefined  NaN

 4. 邏輯或短路運(yùn)算  如果表達(dá)式1 結(jié)果為真 則返回的是表達(dá)式1 如果表達(dá)式1 結(jié)果為假 則返回表達(dá)式2
        alert(123 || 456); // 123
        alert(123 || 456 || 456 + 123); // 123
        alert(0 || 456 || 456 + 123); // 456

邏輯中斷很重要 它會(huì)影響我們程序運(yùn)行結(jié)果
        var num = 0;
        //alert(123 || num++);      //123  num++不會(huì)運(yùn)行
        //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>
        //  一元運(yùn)算符：++num   !num     二元運(yùn)算符： 2 + 3
        // 練習(xí)1
        console.log(4 >= 6 || '人' != '阿凡達(dá)' && !(12 * 2 == 144) && true) //true
        var num = 10;
        console.log(5 == num / 2 && (2 + 2 * num).toString() === '22'); //true
        console.log('-------------------');
        // 練習(xí)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 (條件表達(dá)式) {
            //執(zhí)行語句
        }
        2. 執(zhí)行思路 如果
        if 里面的條件表達(dá)式結(jié)果為真 true 則執(zhí)行大括號(hào)里面的 執(zhí)行語句
        如果if 條件表達(dá)式結(jié)果為假 則不執(zhí)行大括號(hào)里面的語句 則執(zhí)行if 語句后面的代碼
        3. 體驗(yàn)代碼：
        if (3 < 5) {
            alert('沙漠駱駝');
        }

  <script>
        // 彈出 prompt 輸入框，用戶輸入年齡， 程序把這個(gè)值取過來保存到變量中
        // 使用 if 語句來判斷年齡，如果年齡大于18 就執(zhí)行 if 大括號(hào)里面的輸出語句
        var age = prompt('請(qǐng)輸入年齡');
        if (age >= 18) {
            alert('可以進(jìn)入網(wǎng)吧')
        }
    </script>

<script>
        // 1. 語法結(jié)構(gòu)  if 如果  else 否則
        // if (條件表達(dá)式) {
        //     // 執(zhí)行語句1
        // } else {
        //     // 執(zhí)行語句2 
        // }
        // 2. 執(zhí)行思路 如果表達(dá)式結(jié)果為真 那么執(zhí)行語句1  否則  執(zhí)行語句2
        // 3. 代碼驗(yàn)證
        var age = prompt('請(qǐng)輸入您的年齡:');
        if (age >= 18) {
            alert('我想帶你去網(wǎng)吧偷耳機(jī)');
        } else {
            alert('滾， 回家做作業(yè)去');
        }
        // 5. if里面的語句1 和 else 里面的語句2 最終只能有一個(gè)語句執(zhí)行  2選1
        // 6.  else 后面直接跟大括號(hào)
    </script>

  //  算法：能被4整除且不能整除100的為閏年（如2004年就是閏年，1901年不是閏年）或者能夠被 400 整除的就是閏年
        // 彈出prompt 輸入框，讓用戶輸入年份，把這個(gè)值取過來保存到變量中
        // 使用 if 語句來判斷是否是閏年，如果是閏年，就執(zhí)行 if 大括號(hào)里面的輸出語句，否則就執(zhí)行 else里面的輸出語句
        // 一定要注意里面的且 &&  還有或者 || 的寫法，同時(shí)注意判斷整除的方法是取余為 0
         var year = prompt("請(qǐng)輸入要檢測(cè)的年份：")
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            alert(year + '是閏年')
        } else {
            alert(year + '是平年')
        }

<script>
        // 1. 多分支語句   就是利用多個(gè)條件來選擇不同的語句執(zhí)行 得到不同的結(jié)果  多選1 的過程
        // 2. 是多分支語句
        // 3. 語法規(guī)范if else if語句
        if (條件表達(dá)式1) {
            //語句1;
        } else if (條件表達(dá)式2) {
            //語句2;
        } else if (條件表達(dá)式3) {
            //語句3;
        } else {
            //最后語句;
        }
        // 4. 執(zhí)行思路
        // 如果條件表達(dá)式1 滿足就執(zhí)行 語句1 執(zhí)行完畢后，退出整個(gè)if 分支語句  
        // 如果條件表達(dá)式1 不滿足，則判斷條件表達(dá)式2  滿足的話，執(zhí)行語句2 以此類推
        // 如果上面的所有條件表達(dá)式都不成立，則執(zhí)行else 里面的語句
        // 5. 注意點(diǎn)
        // (1) 多分支語句還是多選1 最后只能有一個(gè)語句執(zhí)行
        // (2) else if 里面的條件理論上是可以任意多個(gè)的
        // (3) else if 中間有個(gè)空格了
    </script>

    <script>
        //  偽代碼       按照從大到小判斷的思路
        // 彈出prompt輸入框，讓用戶輸入分?jǐn)?shù)（score），把這個(gè)值取過來保存到變量中
        // 使用多分支 if else if 語句來分別判斷輸出不同的值
        var score = prompt('請(qǐng)輸入分?jǐn)?shù)：');
        if (score >= 90) {
            alert('A');
        } else if (score >= 80) {      //不用寫:90>score>=80 能運(yùn)行下面，一定是小于90的
            alert('B');
        } else if (score >= 70) {
            alert('C');
        } else if (score >= 60) {
            alert('D');
        } else {
            alert('E');      //要帶引號(hào)，不然以為是一個(gè)變量，就要聲明了
        }
    </script>

<script>
        // 1. 有三元運(yùn)算符組成的式子我們稱為三元表達(dá)式
        // 2. 一元運(yùn)算符：++num   二元運(yùn)算符：  3 + 5    三元運(yùn)算符： ? :
        // 3. 語法結(jié)構(gòu) 
        // 條件表達(dá)式 ？ 表達(dá)式1 ： 表達(dá)式2
        // 4. 執(zhí)行思路
        // 如果條件表達(dá)式結(jié)果為真 則 返回 表達(dá)式1 的值 如果條件表達(dá)式結(jié)果為假 則返回 表達(dá)式2 的值
        // 5. 代碼體驗(yàn)
        var num = 10;
        var result = num > 8 ? '是的' : '不是' // 我們知道表達(dá)式是有返回值的,賦值給result 
        console.log(result); //是的
        //等價(jià)于：
        var num = 10;
        if (num > 5) {
            alert('是的');
        } else {
            alert('不是的');
        }
        // 三元表達(dá)式是簡(jiǎn)化版的if else
    </script>

   <script>
        //  用戶輸入0~59之間的一個(gè)數(shù)字
        // 如果數(shù)字小于10，則在這個(gè)數(shù)字前面補(bǔ)0,（加0 拼接） 否則  不做操作
        // 用一個(gè)變量接受這個(gè)返回值，輸出
        var num = prompt('請(qǐng)輸入0~59之間的一個(gè)數(shù)字？')
            //三元表達(dá)式： 表達(dá)式？ 表達(dá)式1： 表達(dá)式2；
        var result = num < 10 ? '0' + num : num; //字符型的0   把返回值賦值給一個(gè)變量
        alert(result);
    </script>

    <script>
        //1. switch 語句也是多分支語句 也可以實(shí)現(xiàn)多選1
        // 2. 語法結(jié)構(gòu) switch 轉(zhuǎn)換、開關(guān)    case小例子或者選項(xiàng)的意思   break 退出
        /*     switch (表達(dá)式) {
                case value1: 執(zhí)行語句1; break;
                case value2: 執(zhí)行語句2; break;
                case value3: 執(zhí)行語句3; break;
                default: 執(zhí)行最后的語句;
            } */
        // 3. 執(zhí)行思路  利用我們的表達(dá)式的值 和 case 后面的選項(xiàng)值相匹配 如果匹配上，就執(zhí)行該case 里面的語句  如果都沒有匹配上，那么執(zhí)行 default里面的語句
        switch (2) {
            case 1: alert('這是1'); break;
            case 2: alert('這是2'); break;  //這是2
            case 3: alert('這是3'); break;
            default: alert('沒有匹配結(jié)果');
        }
    </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. 我們開發(fā)里面 表達(dá)式我們經(jīng)常寫成變量
        // 2. 我們num 的值 和 case 里面的值相匹配的時(shí)候是 全等   必須是值和數(shù)據(jù)類型一致才可以 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>
        //  彈出 prompt 輸入框，讓用戶輸入水果名稱，把這個(gè)值取過來保存到變量中。
        // 將這個(gè)變量作為 switch 括號(hào)里面的表達(dá)式。
        // case 后面的值寫幾個(gè)不同的水果名稱，注意一定要加引號(hào) ，因?yàn)楸仨毷侨绕ヅ洹?
        // 彈出不同價(jià)格即可。同樣注意每個(gè) case 之后加上 break ，以便退出 switch 語句。
        // 將 default 設(shè)置為沒有此水果。
        var fruit = prompt('請(qǐng)輸入水果名稱')
        switch (fruit) {
            case '蘋果':
                alert('蘋果的價(jià)格是 3.5/斤');
                break;
            case '榴蓮':
                alert('榴蓮的價(jià)格是 35/斤');
                break;
            default:
                alert('沒有此水果');
        }
    </script>