摘要：算術(shù)運算符中的算術(shù)操作主要通過算術(shù)運算符來實現(xiàn)，算術(shù)運算符包括一元算術(shù)運算符和二元算術(shù)運算符兩種。一元算術(shù)運算符一元算術(shù)運算符用于一個多帶帶的操作數(shù)，并產(chǎn)生一個新值。

javascript中的算術(shù)操作主要通過算術(shù)運算符來實現(xiàn)，算術(shù)運算符包括一元算術(shù)運算符和二元算術(shù)運算符兩種。

一元算術(shù)運算符用于一個多帶帶的操作數(shù)，并產(chǎn)生一個新值。在javascript中，一元運算符具有很高的優(yōu)先級，而且都是右結(jié)合(right-associative)

一元算術(shù)運算符包括一元加法(+)、一元減法(-)、遞增(++)和遞減(--)

一元加運算符以一個加號(+)表示，放在數(shù)值前面，對數(shù)值不會產(chǎn)生任何影響

var num = 25;
num = +num; //25

在對非數(shù)值應(yīng)用一元加運算符時，會調(diào)用Number()轉(zhuǎn)型函數(shù)對這個值進(jìn)行轉(zhuǎn)換

var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
    valueOf:function(){
        return -1;
    }
};

s1 = +s1;//1
s2 = +s2;//1.1
s3 = +s3;//NaN
b = +b;//0
f = +f;//1.1
o = +o;//-1

在new Date()前面使用一元加符號，可以把日期字符串，轉(zhuǎn)換為日期毫秒數(shù)

console.log(new Date());//on Jul 11 2016 20:25:54 GMT+0800 (中國標(biāo)準(zhǔn)時間)
console.log(+new Date());//1468239954076

一元減運算符主要用于表示負(fù)數(shù)

var num = 25;
num = -num;//-25

當(dāng)一元減運算符用于非數(shù)值時，會對該值使用Number()轉(zhuǎn)型函數(shù)進(jìn)行轉(zhuǎn)換，再將得到的數(shù)值轉(zhuǎn)換成負(fù)數(shù)

var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
    valueOf:function(){
        return -1;
    }
};

s1 = -s1;//-1
s2 = -s2;//-1.1
s3 = -s3;//NaN
b = -b;//0
f = -f;//-1.1
o = -o;//1

一元加和一元減運算符主要用于基本的算術(shù)運算，也可以用于轉(zhuǎn)換數(shù)據(jù)類型

遞增++運算符對其操作數(shù)進(jìn)行增量(加1)操作，操作數(shù)是一個左值(lvalue)(變量、數(shù)組元素或?qū)ο髮傩?。運算符通過Number()轉(zhuǎn)型函數(shù)將操作數(shù)轉(zhuǎn)換為數(shù)字，然后給數(shù)字加1，并將加1后的數(shù)值重新賦值給變量、數(shù)字元素或者對象屬性

var age = 29;
++age;
//相當(dāng)于
var age = 29;
age = age +1;

遞增++運算符的返回值依賴于它相對于操作數(shù)的位置。當(dāng)運算符在操作數(shù)之前，稱為前增量(pre-increment)運算符，它對操作數(shù)進(jìn)行增量計算，并返回計算后的值。當(dāng)運算符在操作數(shù)之后，稱為后增量(post-increment)運算符，它對操作數(shù)進(jìn)行增量計算，但返回未做增量計算的(unincremented)值

var i = 1, j = ++i;
//i=2 j=2

var i = 1, j = i++;
//i=2 j=1

遞減--運算符的操作數(shù)也是一個左值，它通過Number()轉(zhuǎn)型函數(shù)把操作數(shù)轉(zhuǎn)換為數(shù)字，然后減1，并將計算后的值重新賦值給操作數(shù)

和遞增++運算符一樣，遞減--運算符的返回值依賴于它相對操作數(shù)的位置，當(dāng)遞減運算符在操作數(shù)之前，操作數(shù)減1并返回減1之后的值。當(dāng)遞減運算符在操作數(shù)之后，操作數(shù)減1并返回減1之前的值

var age = 29;
--age;
//相當(dāng)于
var age = 29;
age = age - 1;

前增量操作符與執(zhí)行語句優(yōu)先級相同，整個語句會從左向右求值

var num1 = 2;
var num2 = 20;
var num3 = --num1 + num2;//21
var num4 = num1 + num2;//21

后增量操作符在包含它們的語句被求值之后才執(zhí)行

var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2;//22
var num4 = num1 + num2;//21

二元算術(shù)運算符包括加法(+)、減法(-)、乘法(*)、除法(/)和求余(%)

在多數(shù)程序設(shè)計語言中，加法通常是簡單的數(shù)字運算符，但在ECMAScript中，加法運算有大量的特殊行為，不僅可以進(jìn)行數(shù)值加法運算，也可以進(jìn)行字符串連接

【1】如果其中一個操作數(shù)是對象，則對象會轉(zhuǎn)換為原始值：日期對象通過toString()方法執(zhí)行轉(zhuǎn)換，其他對象通過valueOf()方法執(zhí)行轉(zhuǎn)換。由于多數(shù)對象valueOf()方法無法返回一個原始值，于是會通過toString()方法來執(zhí)行轉(zhuǎn)換

[注意]除了單數(shù)值數(shù)組會轉(zhuǎn)換為數(shù)字外，其他原生對象都會通過toString()方法轉(zhuǎn)換為字符串形式

【2】在進(jìn)行了對象到原始值的轉(zhuǎn)換后，如果其中一個操作數(shù)是字符串的話，另一個操作數(shù)也會轉(zhuǎn)換成字符串，進(jìn)行字符串連接，否則，兩個操作數(shù)都將轉(zhuǎn)換成數(shù)字或NaN，進(jìn)行加法操作

//單數(shù)值數(shù)組和valueOf()返回值為數(shù)值的自定義對象會轉(zhuǎn)換為數(shù)值
console.log(1 + []);//1
var o = {
    valueOf: function(){
        return -1;
    }
}
console.log(1 + o);//0

//其他原生對象則轉(zhuǎn)換為字符串
console.log(1 + {});//"1[object Object]"
console.log(1 + [1,2]);//"11,2"
console.log(1 + new Date());//"1Thu Jun 16 2016 10:27:13 GMT+0800 (中國標(biāo)準(zhǔn)時間)"
console.log(1 + /0/);//"1/0/"

如果進(jìn)行算術(shù)加法運算，undefined轉(zhuǎn)換為NaN，null轉(zhuǎn)換為0，false轉(zhuǎn)換為0，true轉(zhuǎn)換為1

console.log("" + undefined);//"undefined"
console.log("" + null);//"null"
console.log("" + false);//"false"
console.log("" + true);//"true"

因此，利用加號運算符的特性，可以利用""+任意類型值轉(zhuǎn)換為字符串

相對于加法，減法就簡單的多，只涉及到數(shù)字的減法運算。使用Number()轉(zhuǎn)型函數(shù)將非數(shù)值類型轉(zhuǎn)換為數(shù)值或NaN

console.log(1 - {});//NaN
console.log(1 - [1,2]);//NaN
console.log(1 - /0/);//NaN
console.log(1 - []);//1

加法有一個特殊之處，在于時間Date對象進(jìn)行加法運算時使用toString()轉(zhuǎn)換為字符串，而在其他數(shù)學(xué)運算，包括減法、乘法、除法、求余等運算中，都是使用Number()轉(zhuǎn)換函數(shù)將時間Date對象使用valueOf()轉(zhuǎn)換為數(shù)字

console.log(new Date() + 1);//"Thu Jun 16 2016 11:11:49 GMT+0800 (中國標(biāo)準(zhǔn)時間)1"
console.log(new Date() - 1);//1466046941641

undefined轉(zhuǎn)換為NaN，null轉(zhuǎn)換為0，false轉(zhuǎn)換為0，true轉(zhuǎn)換為1

console.log(1 - undefined);//NaN
console.log(1 - null);//1
console.log(1 - false);//1
console.log(1 - true);//0

乘法操作符由一個星號(*)表示，用于計算兩個數(shù)值的乘積，會通過Number()轉(zhuǎn)型函數(shù)將非數(shù)值類型轉(zhuǎn)換為數(shù)值或NaN

+ Infinity * 0;//NaN
- Infinity * 0;//NaN
Infinity * 非0數(shù)值;//Infinity或-Infinity
Infinity * Infinity;//Infinity

除法操作符由一個斜線(/)表示，執(zhí)行第一個操作數(shù)除以第二個操作數(shù)的運算，也會通過Number()轉(zhuǎn)型函數(shù)將非數(shù)值類型轉(zhuǎn)換為數(shù)值或NaN

Infinity / Infinity;//NaN
0 / 0;//NaN
非0數(shù)值 / 0;//Infinity或-Infinity
Infinity / 0;//Infinity
Infinity / 非0數(shù)值;//Infinity

求模(余數(shù))操作符是由一個百分號(%)表示，是第一個操作數(shù)除以第二個操作數(shù)的余數(shù)

//r是余數(shù)，n是被除數(shù)，d是除數(shù)，
//q是整數(shù)，在n/d為負(fù)時為負(fù)，在n/d為正時為正，它應(yīng)該在不超過n和d的商的前提下盡可能大
r = n - (d * q)

求模結(jié)果與第一個操作數(shù)的符號保持一致

console.log(5 % 2);//1
console.log(5 % -2);//1
console.log(-5 % 2);//-1
console.log(-5 % -2);//-1

關(guān)系運算符用于測試兩個值之間的關(guān)系，根據(jù)關(guān)系是否存在而返回true或false，關(guān)系表達(dá)式總是返回一個布爾值，通常在if、while或for語句中使用關(guān)系表達(dá)式，用以控制程序的執(zhí)行流程

javascript提供了===、!==、==、!=、<、<=、>、>=8個關(guān)系運算符，分為4類介紹關(guān)系運算符

恒等運算符"==="，也叫嚴(yán)格相等運算符，首先計算其操作數(shù)的值，然后比較這兩個值，比較過程沒有任何類型轉(zhuǎn)換，比較過程如下：

【1】如果兩個值的類型不相同，則返回false

console.log(1 === "1");//false
console.log(1 === [1]);//false

【2】如果兩個值都是Undefined、Null、Boolean、Number、String相同原始類型的值，值相同，就返回true，否則，返回false

console.log(undefined === undefined);//true
console.log(null === null);//true
console.log(true === true);//true
console.log(false === false);//true
console.log(1 === 1);//true
console.log(2.5 === 2.5);//true

[注意]不論什么進(jìn)制的數(shù)字，在進(jìn)行關(guān)系比較時，最終都轉(zhuǎn)換為十進(jìn)制進(jìn)行運算

console.log(10 === 0xa);//true

在數(shù)字Number類型中，有一個值比較特殊，是NaN(not a number)，它與任何值都不相等；此外，數(shù)字Number類型中存在著+0和-0，雖然其符號不同，但值相等

console.log(NaN === NaN);//false
console.log(+0 === -0);//true

兩個相同字符串值表現(xiàn)為：相同的長度和相同的字符對應(yīng)相同的位置

console.log("abc" === "abc");//true
console.log("abc" === "acb");//false

【3】如果兩個值引用同一個對象，則返回true，否則，返回false

[注意]更詳細(xì)的解釋是，javascript對象的比較是引用的比較，而不是值的比較。對象和其本身是相等的，但和其他任何對象都不相等。如果兩個不同的對象具有相同數(shù)量的屬性，相同的屬性名和值，它們依然是不相等的

console.log([] === []);//false
console.log({} === {});//false    
console.log(function(){} === function(){});//false
var a = {};
b = a;
console.log(a === b);//true

恒不等運算符(!==)又叫嚴(yán)格不等于運算符，操作數(shù)的比較過程與恒等運算符相同，結(jié)果取反。如果"==="的比較結(jié)果是true，則"!=="的比較結(jié)果是false；如果"==="的比較結(jié)果是false，則"!=="的比較結(jié)果是true

console.log(1 !== "1");//true
console.log(1 !== 1);//false
console.log(true !== false);//true
console.log({} !== {});//true

相等運算符"=="和恒等運算符相似，但相等運算符的比較并不嚴(yán)格，如果兩個操作數(shù)不是同一類型，相等運算符會嘗試進(jìn)行一些類型轉(zhuǎn)換，然后再進(jìn)行比較

當(dāng)兩個操作數(shù)類型相同時，比較規(guī)則和恒等運算符規(guī)則相同

console.log(undefined == undefined);//true
console.log(10 == 0xa);//true
console.log(NaN == NaN);//false
console.log([] == []);//false

當(dāng)兩個操作數(shù)類型不同時，相等運算符"=="會遵守如下規(guī)則：

【1】如果一個值是對象類型，另一值是原始類型，則對象類型會先使用valueOf()轉(zhuǎn)換成原始值，如果結(jié)果還不是原始值，則再使用toString()方法轉(zhuǎn)換，再進(jìn)行比較

[注意]日期類只允許使用toString()方法轉(zhuǎn)換為字符串。類似地，時間Date對象進(jìn)行加法運算時使用toString()轉(zhuǎn)換為字符串，而在其他數(shù)學(xué)運算，包括減法、乘法、除法、求余等運算中，都是使用Number()轉(zhuǎn)換函數(shù)將時間Date對象使用valueOf()轉(zhuǎn)換為數(shù)字

【2】在對象轉(zhuǎn)換為原始值之后，如果兩個操作數(shù)都是字符串，則進(jìn)行字符串的比較

console.log(new Date() == "Sat Jun 25 2016 11:07:20 GMT+0800 (中國標(biāo)準(zhǔn)時間)");//true

【3】在對象轉(zhuǎn)換為原始值之后，如果至少有一個操作數(shù)不是字符串，則兩個操作數(shù)都將通過Number()轉(zhuǎn)型函數(shù)轉(zhuǎn)換成數(shù)字進(jìn)行數(shù)值比較

console.log(true == 1);//true
console.log(true == 0);//false
console.log(false == "1");//false
console.log(false == "0");//true
console.log(true == "true");//false，相當(dāng)于1 == NaN

console.log([1] == 1);//true，相當(dāng)于1 == 1
console.log([1] == "1");//true，相當(dāng)于"1" == "1"
console.log([] == 0);//true，相當(dāng)于0 == 0
console.log([] == "0");//false，相當(dāng)于"" == "0"

console.log([] == true);//false，相當(dāng)于0 == 1
console.log([1] == true);//true，相當(dāng)于1 == 1

var a = {
    valueOf:function(){
        return 1;
    },
    toString:function(){
        return "2";
    }
} 
console.log( a == "1");//true，相當(dāng)于1 == 1

var a = {
    valueOf:function(){
        return {};
    },
    toString:function(){
        return "1";
    }
} 
console.log( a == 1);//true，相當(dāng)于1 == 1

[注意]如果一個值是null，另一個值是undefined，則返回true。雖然Number(null)是0，但null和0并不相等

console.log(null == undefined);//true
console.log(null == 0);//false

[注意]空字符串或空格字符串會轉(zhuǎn)成0

console.log(null == []);//false
console.log(null == "");//false
console.log([] == " ");//false，相當(dāng)于"" == " "
console.log([] == "");//true，相當(dāng)于"" == ""
console.log(0 == "");//true

不相等運算符(!=)的操作數(shù)比較過程與相等運算符相同，結(jié)果取反。如果"=="的比較結(jié)果是true，則"!="的比較結(jié)果是false；如果"=="的比較結(jié)果是false，則"!="的比較結(jié)果是true

console.log(1 != "1");//false，相當(dāng)于1 != 1
console.log(true != "1");//false，相當(dāng)于1 != 1
console.log("true" != 1);//true，相當(dāng)于NaN != 1
console.log([1] != "1");//false，相當(dāng)于"1" != "1"
console.log([1] != true);//false，相當(dāng)于1 != 1

大于運算符(>)用于比較兩個操作數(shù)，如果第一個操作數(shù)大于第二個操作數(shù)，則大于運算符的計算結(jié)果為true，否則為false

大于運算符的操作數(shù)可能是任意類型，然而，只有數(shù)字和字符串才能真正執(zhí)行比較操作，因此那些不是數(shù)字和字符串的操作數(shù)都將進(jìn)行類型轉(zhuǎn)換，類型轉(zhuǎn)換規(guī)則如下：

【1】如果操作數(shù)是對象，則這個對象將先使用valueOf()轉(zhuǎn)換成原始值，如果結(jié)果還不是原始值，則再使用toString()方法轉(zhuǎn)換

[注意]實際上，在原生對象中，使用valueOf()方法轉(zhuǎn)換為原始值的，只有轉(zhuǎn)換為數(shù)字Number類型的時間Date對象，其他對象都通過toString()方法轉(zhuǎn)換為字符串

【2】在對象轉(zhuǎn)換為原始值之后，如果兩個操作數(shù)都是字符串，則按照字母表的順序?qū)蓚€字符串進(jìn)行比較，這里提到的字母表順序是指組成這個字符串的16位unicode字符的索引順序

console.log("b" > "a");//true
console.log("B" > "a");//false

console.log({} > "[a]");//true，相當(dāng)于"[object Object]" > "[a]"
console.log({} > "[p]");//false，相當(dāng)于"[object Object]" > "[p]"

console.log(["a"] > ["b"]);//false，相當(dāng)于"a" > "b"
console.log([2] > [11]);//true，相當(dāng)于"2" > "11"

【3】在對象轉(zhuǎn)換為原始值之后，如果至少有一個操作數(shù)不是字符串，則兩個操作數(shù)都轉(zhuǎn)換成數(shù)字進(jìn)行比較

[注意]在等于操作符中，時間Date()對象只允許通過toString()方法轉(zhuǎn)換為字符串，而不允許通過valueOf()方法轉(zhuǎn)換為數(shù)字；而在大于操作符中，時間Date()對象允許優(yōu)先使用valueOf()方法轉(zhuǎn)換為數(shù)字

console.log(new Date() > 100);//true，相當(dāng)于1466826928667 > 100
console.log(true > [0]);//true，相當(dāng)于 1 > 0

console.log(2 > 1);//true
console.log(11 > "2");//true，相當(dāng)于11 > 2

console.log(NaN > 1);//false
console.log(1 > NaN);//false
console.log({} > true);//false，相當(dāng)于 NaN > 1

對于數(shù)字和字符串來說，加號運算符和比較運算符的行為有所不同，加號運算符更偏愛字符串，如果它的一個操作數(shù)是字符串，就進(jìn)行字符串連接。而比較運算符則更偏愛數(shù)字，只有在兩個操作數(shù)都是字符串時，才進(jìn)行字符串的比較

console.log(1 + 2);//3
console.log("1" + "2");//"12"
console.log("1" + 2);//"12"，相當(dāng)于 "1" + "2"

console.log(2 > 1);//true
console.log("2" > "1");//true
console.log("2" > 1);//true，相當(dāng)于 2 > 1

小于等于運算符(<=)并不依賴于小于或等于運算符的比較規(guī)則，而是遵循大于運算符的比較規(guī)則，結(jié)果取反。如果">"的比較結(jié)果是true，則"<="的比較結(jié)果是false；如果">"的比較結(jié)果是false，則"<="的比較結(jié)果是true

console.log(1 <= "0");//false，相當(dāng)于1 <= 0
console.log(true <= "0");//false，相當(dāng)于1 <= 0
console.log("true" <= 0);//false，相當(dāng)于NaN <= 0
console.log([1] <= "0");//false，相當(dāng)于"1" <= "0"
console.log([0] <= true);//true，相當(dāng)于0 <= 1
console.log(1 <= 1);//true

小于運算符(<)用于比較兩個操作數(shù)，如果第一個操作數(shù)小于第二個操作數(shù)，則小于運算符的計算結(jié)果為true，否則為false

小于運算符與大于運算符的類型轉(zhuǎn)換規(guī)則類似，就不再贅述

同樣地，大于等于運算符(>=)并不依賴于大于或等于運算符的比較規(guī)則，而是遵循小于運算符的比較規(guī)則，結(jié)果取反。如果"<"的比較結(jié)果是true，則">="的結(jié)果是false；如果"<"的比較結(jié)果是false，則">="的結(jié)果是true

邏輯運算符對操作數(shù)進(jìn)行布爾運算，經(jīng)常和關(guān)系運算符一樣配合使用。邏輯運算符將多個關(guān)系表達(dá)式組合起來組成一個更復(fù)雜的表達(dá)式。邏輯運算符分為邏輯非"!"、邏輯與"&&"、邏輯或"||"3種。

邏輯非操作符由一個嘆號(!)表示，可以應(yīng)用于ECMAScript中的任何值。無論這個值是什么數(shù)據(jù)類型，這個操作符都會返回一個布爾值。邏輯非操作符首先會將它的操作數(shù)轉(zhuǎn)換成一個布爾值，然后再對其求反

邏輯非對操作數(shù)轉(zhuǎn)為布爾類型的轉(zhuǎn)換類型與Boolean()轉(zhuǎn)型函數(shù)相同，只不過最后再將其結(jié)果取反。而如果同時使用兩個邏輯非操作符，實際上就會模擬Boolean()轉(zhuǎn)型函數(shù)的行為

console.log(!!undefined);//false
console.log(!!null);//false
console.log(!!0);//false
console.log(!!-0);//false
console.log(!!NaN);//false
console.log(!!"");//false
console.log(!!false);//false

console.log(!!{});//true
console.log(!![]);//true

console.log(!!new Boolean(false));//true
console.log(!!false);//false
console.log(!!new Boolean(null));//true
console.log(!!null);//false

邏輯與運算符由兩個和號(&&)表示，有兩個操作數(shù)，只有在兩個操作數(shù)都為true時，結(jié)果才返回true，否則返回false

//邏輯與(&&)的真值表
第一個操作數(shù)        第二個操作數(shù)        結(jié)果
true              true               true
true              false              false
false             true               false
false             false              false

邏輯與操作可以應(yīng)用于任何類型的操作數(shù)，而不僅僅是布爾值。如果其中一個操作數(shù)不是布爾值，則邏輯與操作不一定返回布爾值
邏輯與操作屬于短路操作，如果第一個操作數(shù)能夠決定結(jié)果，那么就不會再對第二個操作數(shù)求值
對于邏輯與而言:
如果第一個操作數(shù)是false，則無論第二個操作數(shù)是什么值，結(jié)果都是false，則返回第一個操作數(shù)；
如果第一個操作數(shù)為true，則結(jié)果的真假和第二個操作數(shù)的真假相同，則返回第二個操作數(shù)

//除了false、undefined、null、+0、-0、NaN、""這7個假值，其余都是真值

console.log("t" && ""); //因為"t"是真值，所以返回""
console.log("t" && "f"); //因為"t"是真值，所以返回"f"
console.log("t" && 1 + 2); //因為"t"是真值，所以返回3
console.log("" && "f"); //因為""是假值，所以返回""
console.log("" && ""); //因為""是假值，所以返回""

var i = 1;
var result = (true && i++);
console.log(result,i);//因為true是真值，所以執(zhí)行i++，i是2，result是1

var i = 1;
var result = (false && i++);
console.log(result,i);//因為false是假值，所以不執(zhí)行i++，i是1，result是false

邏輯與運算符可以多個連用，返回第一個布爾值為false的表達(dá)式的值

console.log(true && "foo" && "" && 4 && "foo" && true);// ""

邏輯或運算符由兩個豎線(||)表示，有兩個操作數(shù)，只有在兩個操作數(shù)都是false時，結(jié)果才返回false，否則返回true

//邏輯或(||)的真值表
第一個操作數(shù)        第二個操作數(shù)        結(jié)果
true              true              true
true              false             true
false             true              true
false             false             false

同樣地，邏輯或操作也可以應(yīng)用于任何類型的操作數(shù)，而不僅僅是布爾值。如果其中一個操作數(shù)不是布爾值，則邏輯或操作不一定返回布爾值
邏輯或操作也屬于短路操作，如果第一個操作數(shù)能夠決定結(jié)果，那么就不會再對第二個操作數(shù)求值
對于邏輯或而言：
如果第一個操作數(shù)是true，則無論第二個操作數(shù)是什么值，結(jié)果都是true，則返回第一個操作數(shù)；
如果第一個操作數(shù)是false，則結(jié)果的真假和第二個操作數(shù)的真假相同，則返回第二個操作數(shù)

console.log("t" || "");//因為"t"是真值，所以返回"t"
console.log("t" || "f");//因為"t"是真值，所以返回"t"
console.log("" || "f");//因為""是假值，所以返回"f"
console.log("" || "");//因為""是假值，所以返回""

var i = 1;
var result = (true || i++);
console.log(result,i);//因為true是真值，所以不執(zhí)行i++，result是true，i是1

var i = 1;
var result = (false || i++);
console.log(result,i);//因為false是假值，所以執(zhí)行i++，i是2，result是1

同樣地，邏輯或運算符也可以多個連用，返回第一個布爾值為true的表達(dá)式的值

console.log(false || 0 || "" || 4 || "foo" || true);// 4

條件運算符是javascript中唯一的一個三元運算符(三個操作數(shù))，有時直接稱做三元運算符。通常這個運算符寫成?:，當(dāng)然在代碼中往往不會這么簡寫，因為這個運算符擁有三個操作數(shù)，第一個操作數(shù)在?之前，第二個操作數(shù)在?和:之間，第三個操作數(shù)在:之后

variable = boolean_expression ? true_value : false_value;

本質(zhì)上，這就是基于對boolean_expression求值的結(jié)果，決定給變量variable賦什么值。如果求值結(jié)果是true，則給變量variable賦值true_value；如果求值結(jié)果是false，則給變量variable賦值false_value

條件運算符的操作數(shù)可以是任意類型，第一個操作數(shù)當(dāng)成布爾值，如果它是真值，那么將計算第二個操作數(shù)，并返回其計算結(jié)果。否則，如果第一個操作數(shù)是假值，那么將計算第三個操作數(shù)，并返回其計算結(jié)果。第二個和第三個操作數(shù)總是會計算其中之一，不可能兩者同時執(zhí)行

其實使用if語句也會帶來同樣的效果，"?:"運算符只是提供了一種簡寫形式。下面是一個"?:"的典型應(yīng)用場景，判斷一個變量是否有定義(并擁有一個有意義的真值)，如果有定義則使用它，如果無定義則使用一個默認(rèn)值:

greeting = "hello " + (username ? username : "there");

圓括號運算符也叫分組運算符，它有兩種用法：如果表達(dá)式放在圓括號中，作用是求值；如果跟在函數(shù)后面，作用是調(diào)用函數(shù)

把表達(dá)式放在圓括號之中，將返回表達(dá)式的值

console.log((1));  //1
console.log(("a")); //"a"
console.log((1+2)); // 3

把對象放在圓括號之中，則會返回對象的值，即對象本身

var o = {p:1};
console.log((o));// Object {p: 1}

將函數(shù)放在圓括號中，會返回函數(shù)本身。如果圓括號緊跟在函數(shù)的后面，就表示調(diào)用函數(shù)，即對函數(shù)求值

function f(){return 1;}
console.log((f));// function f(){return 1;}
console.log(f()); // 1

[注意]圓括號運算符不能為空，否則會報錯