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

javascript中的算術操作主要通過算術運算符來實現，算術運算符包括一元算術運算符和二元算術運算符兩種。

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

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

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

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

在對非數值應用一元加運算符時，會調用Number()轉型函數對這個值進行轉換

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()前面使用一元加符號，可以把日期字符串，轉換為日期毫秒數

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

一元減運算符主要用于表示負數

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

當一元減運算符用于非數值時，會對該值使用Number()轉型函數進行轉換，再將得到的數值轉換成負數

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

一元加和一元減運算符主要用于基本的算術運算，也可以用于轉換數據類型

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

var age = 29;
++age;
//相當于
var age = 29;
age = age +1;

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

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

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

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

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

var age = 29;
--age;
//相當于
var age = 29;
age = age - 1;

前增量操作符與執行語句優先級相同，整個語句會從左向右求值

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

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

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

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

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

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

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

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

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

//其他原生對象則轉換為字符串
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 (中國標準時間)"
console.log(1 + /0/);//"1/0/"

如果進行算術加法運算，undefined轉換為NaN，null轉換為0，false轉換為0，true轉換為1

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

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

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

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

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

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

undefined轉換為NaN，null轉換為0，false轉換為0，true轉換為1

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

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

+ Infinity * 0;//NaN
- Infinity * 0;//NaN
Infinity * 非0數值;//Infinity或-Infinity
Infinity * Infinity;//Infinity

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

Infinity / Infinity;//NaN
0 / 0;//NaN
非0數值 / 0;//Infinity或-Infinity
Infinity / 0;//Infinity
Infinity / 非0數值;//Infinity

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

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

求模結果與第一個操作數的符號保持一致

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

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

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

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

【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

[注意]不論什么進制的數字，在進行關系比較時，最終都轉換為十進制進行運算

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

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

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

兩個相同字符串值表現為：相同的長度和相同的字符對應相同的位置

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

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

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

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

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

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

相等運算符"=="和恒等運算符相似，但相等運算符的比較并不嚴格，如果兩個操作數不是同一類型，相等運算符會嘗試進行一些類型轉換，然后再進行比較

當兩個操作數類型相同時，比較規則和恒等運算符規則相同

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

當兩個操作數類型不同時，相等運算符"=="會遵守如下規則：

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

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

【2】在對象轉換為原始值之后，如果兩個操作數都是字符串，則進行字符串的比較

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

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

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，相當于1 == NaN

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

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

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

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

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

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

[注意]空字符串或空格字符串會轉成0

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

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

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

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

大于運算符的操作數可能是任意類型，然而，只有數字和字符串才能真正執行比較操作，因此那些不是數字和字符串的操作數都將進行類型轉換，類型轉換規則如下：

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

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

【2】在對象轉換為原始值之后，如果兩個操作數都是字符串，則按照字母表的順序對兩個字符串進行比較，這里提到的字母表順序是指組成這個字符串的16位unicode字符的索引順序

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

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

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

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

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

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

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

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

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

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

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

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

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

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

小于運算符與大于運算符的類型轉換規則類似，就不再贅述

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

邏輯運算符對操作數進行布爾運算，經常和關系運算符一樣配合使用。邏輯運算符將多個關系表達式組合起來組成一個更復雜的表達式。邏輯運算符分為邏輯非"!"、邏輯與"&&"、邏輯或"||"3種。

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

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

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

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

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

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

//除了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是真值，所以執行i++，i是2，result是1

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

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

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

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

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

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

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是真值，所以不執行i++，result是true，i是1

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

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

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

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

variable = boolean_expression ? true_value : false_value;

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

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

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

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

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

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

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

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

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

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

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

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