運算符

運算符(Operators，也翻譯為操作符)，是發(fā)起運算的最簡單形式。

運算符的分類見仁見智，我們的課程對運算符進行如下分類：

數(shù)學運算符(Arithmetic operators)
比較運算符(Comparison operators)
邏輯運算符(Logical operators)
賦值運算符(Assignment operators)
按位運算符(Bitwise operators)
條件 (三元) 運算符(Conditional operator)

1.數(shù)學運算符

+ - * / % ()

• 這里面要知道%的意思，我們昨天已經(jīng)算過很多了，不贅述。
• 要知道計算順序，先乘除求余，然后加減，我們昨天已經(jīng)算過很多了，不贅述。
• 隱式轉換，所有帶有字符串的運算都會盡可能的轉為數(shù)字進行計算，加號比較特殊。

數(shù)學運算符的正統(tǒng)，是number和number的數(shù)學運算，結果是number。出于面試的考慮，有一些奇奇怪怪的數(shù)學運算：

數(shù)學運算中，只有純字符串、布爾值、null能夠幫你進行隱式轉換：

//隱式轉換：就是沒有寫parseInt()、parseFloat()自己幫你轉格式
        
console.log(3 * "8");   //24
console.log("3" * "8"); //24
console.log("48" / "2"); //24
console.log("24" % 55); //24

console.log(3 * null); //0   隱式轉換的時候null將被轉為0
console.log(3 * false); //0  隱式轉換的時候false將被轉為0
console.log(3 * true);  //3  隱式轉換的時候true將被轉為1

不純的字符串和undefined是不能幫你進行隱式轉換的，結果都是NaN

console.log(3 * "8天");  //NaN   數(shù)學運算中，不純的字符串沒法隱式轉換
console.log(3 * undefined); //NaN  數(shù)學運算中，undefined不能進行隱式轉換

加法比較特殊，因為+同時是加法和連字符的符號，所以加法在面對字符串的時候沒有隱式轉換

//加法沒有隱式轉換
console.log(3 + "8");           //38
console.log(3 + undefined); //NaN   
console.log(3 + null);      //3
console.log(3 + false);     //3
console.log(3 + true);      //4

總結：
無論哪種運算，只要出現(xiàn)了undefined參與運算，結果都是NaN。
然后"4"、false、true、null都能進行隱式轉換。
加號比較特殊，面對"4"沒有隱式轉換的

特殊數(shù)值的計算，就是NaN、Infinity參與的運算，我們看《高3》來學習。
我們就舉幾個例子：

Infinity + 1000   //Infinity
Infinity - 1000  //Infinity
Infinity / 1000 //Infinity 
Infinity - Infinity //NaN
Infinity /Infinity  //NaN
Infinity * Infinity //Infinity
0 / 0 //NaN
6 / 0 //Infinity
NaN / 8 //NaN

2.關系運算符

>     大于
<     小于
>=   大于等于
<=   小于等于
==   等于
!=    不等于
=== 全等于
!==  不全等

關系運算符的正統(tǒng)，number和number進行數(shù)學運算，得到的答案boolean。

console.log(8 > 5); //true
console.log(7 < 4); //false

關系運算的結果，是boolean類型的。

true和false叫做布爾值。boolean類型，boolean類型只有兩個值，就是true和false。表示真、假。

== 我們叫做“相等判斷”，它會幫你進行一個隱式轉換，盡可能的得到true的答案：
console.log(5 == "5"); //true
===我們叫做“全等判斷”，不僅僅比較數(shù)值是否相等，還比較類型是否相等

!= 是==的反面，如果==運算是true，那么!=就是false
!==是===的反面，如果===運算是true，那么!==就是false

console.log(5 != "5");  //false ，腦子要反著想一下，5=="5"結果是t，所以就是f

console.log(5 !== "5"); //true ，腦子要反著想一下，5==="5"結果是f，所以就是t

正統(tǒng)的運算講完了，number和number進行關系運算，結果是boolean。
現(xiàn)在我們講一丟丟不正統(tǒng)的關系運算，為了面試，劃一下重點，更多的自己通過《高三》P50、P51、P52：
① string 和 string 也能夠進行關系運算，比較的就是字符編碼順序。

字符編碼順序，就是數(shù)字、大寫字母、小寫字母

"a" < "b" //true
"A" < "B" //true
"A" < "a" // true ，大寫字母在字符集里面是在小寫字母前面
"1" < "A"  //true ，數(shù)字在字母前端
"blank" < "blue"  //true   因為一位一位比，直到比出大小
"25678" < "3"   //true  因為是string和string比，比的是字符編碼順序

② 與數(shù)字進行關系運算時，純數(shù)字字符串被轉為數(shù)字，null轉換為0，true轉換轉為1， false轉換為0，null不能進行和0的相等判定。

null < 0.00001  //true
null > -0.0001  //true
null == 0  //false  具體原因，我們后面講解Object的時候介紹
false == 0  //true
true == 1 //true

③ NaN不等于自己，不全等于自己

NaN == NaN  //false
NaN === NaN  //false
NaN != NaN //true
NaN !== NaN //true

④ string 和 number比，string會被隱式轉換為number
"25" < 3 //false

需要注意的是，我們已經(jīng)了解了一些不正統(tǒng)的運算，所以不要出洋相，不能連續(xù)使用關系運算符！！
比如我們想驗證3大于2,2大于1：
表達式：
3 > 2 > 1

的值是多少？
解：原式=(3>2) >1 = true > 1 = false (因為true會被當做1來與1進行比較)

也就是說，不能連續(xù)使用關系運算符??！因為一旦連續(xù)使用了，實際上還是從左至右計算，所以就有上一步的boolean參與了下一步的運算。
劇透一下，如果想要使用連續(xù)關系運算，1<2 && 2<3

3.邏輯運算符

邏輯運算符就三個：

&&  邏輯與運算
||  邏輯或運算
!   邏輯非運算

正統(tǒng)來說，參與邏輯運算的是boolean和boolean，得到的結果也是boolean
值按照真值表來定。

&& 邏輯與，“且”

`&&` 邏輯與，“且”

“都真才真”，“有假就假”。
命題1：“地球是圓的” 真的
命題2：“宋仲基很帥” 真的
命題1 且 命題2 真的

命題1：“1+1=3” 假的
命題2：“地球是方的” 假的
命題1 且 命題2 假的

//邏輯運算符
console.log(true && true);      //t
console.log(true && false);     //f
console.log(false && true);     //f
console.log(false && false);        //f

|| 邏輯或，“或者”的意思

“有真就真”，“都假才假”

命題1： 1 + 1 = 2
命題2：“邵老師很帥”
命題1 或者 命題2 總結果是真

console.log(true || true);      //t
console.log(true || false);     //t
console.log(false || true);     //t
console.log(false || false);    //f 

!就是“邏輯非”，相反的

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

運算順序是非、與、或

true || false && !true || false;
解：原式 = true || false && false || false
 = true || false || false
 = true || false
 = true

邏輯運算符最最有意思的事情，就是所謂的“短路語法”。
就是你發(fā)現(xiàn)沒有，

如果計算一個且運算的時候，比如a && b，a如果就是一個false，那么就不會管b是什么，直接輸出false就行了，等于說直接輸出a。如果計算一個且運算的時候，比如 a && b ，a如果就是一個true，那么也不用管b是什么，直接把b當做結果輸出就行了。

也就是說，本質上計算機進行a&&b運算的時候，不是在進行邏輯分析，這小子就想著要么扔a，要么扔b。如果a是負性的，那么直接扔出a；如果a是正性的，直接扔出b。
—— 短路語法。 要么a被短路，要么b被短路。

負性的：false，null， 0， NaN， 空字符串("")，undefined
正性的：除了上面的，全是正性的。

false && 8   //false  因為計算機發(fā)現(xiàn)，且運算a已經(jīng)是false了，直接輸出false
null && 8   //null  因為計算機發(fā)現(xiàn)，且運算a已經(jīng)是false性的了，直接扔出來null
true && 13   //13   因為計算機發(fā)現(xiàn)，且運算a是true，所以總結果就是看b，直接扔出b
12 && 13    //13   因為計算機發(fā)現(xiàn)，12當做true，所以總結果看b，直接扔出b
13 && 12    //12   因為計算機發(fā)現(xiàn)，13當做true，所以總結果看b，直接扔出b
undefined && 哈哈  //undefined  不報錯，因為a已經(jīng)是負性的了，所以直接扔出a，哈哈不管
哈哈 && undefined  //報錯
true && NaN    //NaN  扔后面

|| 邏輯或的短路也是類似的，a||b
計算機發(fā)現(xiàn)a是真，那么扔a；如果a是假，那么扔b

0 || 18   //18 前面假，扔后面
18 || 0   //18 前面真，扔前面
undefined || NaN    //NaN  前面假，扔后面
NaN || undefined    //undefined 前面假，扔后面

88 || 99 && 66 || 55
解：原式 = 88 || 66 || 55
= 88 || 55
= 88

undefined && ("3" != 3) || NaN && null
解： 原式 = undefined && false || NaN && null
= undefined || NaN && null
= undefined || NaN
= NaN

總結一下短路語法：
a&&b， 計算機要么執(zhí)行a要么執(zhí)行b。a真執(zhí)行b，a假執(zhí)行a；
a||b， 計算機要么執(zhí)行a要么執(zhí)行b。a真執(zhí)行a，a假執(zhí)行b。

千萬不要背，從真值表中自己推倒。

4.賦值運算符

=   賦值
+=  簡便寫法
-=  簡便寫法
*=  簡便寫法
/=  簡便寫法
%=  簡便寫法
++
--

賦值運算的參與者，一定是變量。

var a = 1;
a += 2;            //這行語句等價于a = a + 2;
console.log(a);     //3

var b = 6;
b /= 3;   //等價于b = b / 3
console.log(b);     //2

var c = 100;
c %= 10;        //等價于c = c % 10;
console.log(c); //0

var a = "我";
a += "愛";
a += "你";
console.log(a);

++運算符：

var e = 10;
e++;            //等價于e=e+1
console.log(e); //11

++可以與輸出語句寫在一起，++寫在變量前和寫在變量后不是一個意思。

a++ : 先用a的原值，然后a加1；
++a ：先給a加1，然后用a的新值

var f = 10;
console.log(f++);   //10 ，先引用原值，然后加1

等價于：

//等價于
var f= 10;
console.log(f);   //先輸出f
f++;              //然后f加1

var g = 10;
console.log(++g);    //11 ， 這次是先加1，然后輸出

++有花式玩兒法，僅面試有用：

var a = 8;
console.log(4 + a++);   //12  ， 先使用原來的a的值，就是4+8，輸出12.然后a加1
console.log(a);     //9

var i = 9;
console.log(++i % 5);   //0  , 先把i加1，然后使用i，10%5=0
console.log(i);     //10

運算符的計算順序：
++ -- !貼身的 →→→ 數(shù)學 →→→ 比較 →→→ 邏輯 →→→ 賦值

var a = 3 < 6 && 7 < 14;    //true
原式 = true && true
     = true

var a = 1 + 2 < 3 + 3 && 3 + 4 < 2 * 7; 
原式 = 3 < 6 && 7 < 14
     = 上一題 
     = true

var a = false + true && 13;
原式 = 0 + 1 && 13
     = 1 && 13
     = 13

var a = 15;
false + a++ + true > 8 && 13 || 6
原式 = false + 15 + true > 8 && 13 || 6
     = 16 > 8 && 13 || 6
     = true && 13 || 6
     = 13 || 6
     = 13

條件分支語句

1.if語句

如果……否則…… ， 讓程序出現(xiàn)分支

<script type="text/javascript">
    var a = 8;
    if(a >= 60){
        alert("及格了");
    }else{
        alert("不及格");
    }
</script>

語法：

if(測試表達式){
    測試表達式為真執(zhí)行的語句
}else{
    測試表達式為假執(zhí)行的語句5   }

if英語里面的如果的意思，else就是否則的意思。else不要拼寫為eles。

在語法層面有兩個特例：
① 可以沒有else部分

var a = 1;
if(a >= 60){
    alert("及格了");4  }

② 如果要執(zhí)行的語句，只有一行語句，那么就是單行if，就可以省略大括號。

var a = 112;
if(a >= 60) 
    alert("及格了");
else
    alert("不及格");

注意if語句是一個結構體，注意哪些語句是在結構體中，哪些語句不是結構體：

var a = 355;
if(a > 30){
    console.log("哈哈");
    console.log("嘻嘻");
    console.log("呵呵");
}else{
    console.log("納尼");
    console.log("呸呸")
}
console.log("么么噠");  /*一定會執(zhí)行，在if結構體外面*/

小練習：用戶輸入一個年齡，判斷用戶能不能考取駕照。交規(guī)說： 大于等于18，小于等于70才能考取駕照。

//讓用戶輸入年齡
var age = parseInt(prompt("請輸入年齡"));
//判斷
if(age >= 18 && age <= 70){
    alert("可以考取駕照");
}else{
    alert("年齡不符合要求");
}
alert("謝謝惠顧");

多分支的if
if……else if …… else if…… else if…… else ……

如果……否則如果……否則如果……否則如果……否則……

跳樓現(xiàn)象，用戶會選擇一個分支執(zhí)行（跳樓），選擇這個分支了，就暗含了上一個分支沒有滿足：

var score = 76;

if(score >= 85){
    alert("優(yōu)秀");   //不滿足條件，所以不執(zhí)行，走樓梯下樓
}else if(score >= 70){
    alert("良好");   //走到這個樓層的，一定暗含小于85。這一樓層滿足，跳樓了
}else if(score >= 60){
    alert("及格");  //不執(zhí)行
}else{
    alert("不及格")  //不執(zhí)行
}

語法：

if(測試表達式1){
    測試表達式1為真的時候做的事情
}else if(測試表達式2){
    測試表達式1為假，且測試表達式2為真的時候做的事情
}else if(測試表達式3){
    測試表達式1為假，測試表達式2為假，且測試表達式3為真的時候做的事情
}
……

if語句的嵌套：
用戶先輸入自己的性別，比如男、女。然后輸入自己的年齡。判斷能否結婚。
男的22以上
女的20以上

if語句可以嵌套，如果里面再套一層如果：

//判斷
if(sex == "男"){
    //男
    if(age >= 22){
        alert("男同志你好，可以結婚");
    }else{
        alert("你還是個小正太，不能結婚！");
    }
}else{
    //女
    if(age >= 20){
        alert("女同志你好，可以結婚");
    }else{
        alert("你還是個小蘿莉，不能結婚！");
    }
}

樓層中else只能有一個。 else if可以有多個。