摘要：一元運算符一元運算符只能操作一個值。邏輯非邏輯非參考數據判斷邏輯非運算符可以用于任何值。無論這個值是什么數據類型，這個運算符都會返回一個布爾值。

前端學習：教程&開發模塊化/規范化/工程化/優化&工具/調試&值得關注的博客/Git&面試-前端資源匯總

歡迎提issues斧正：運算符

JavaScript 有一系列操作數據值的運算符，運算符按照特定運算規則對操作數進行運算，將簡單的表達式組合成復雜的表達式。

一元運算符只能操作一個值。

累加累減運算符：

var xzavier = 123;
xzavier++  //把變量累加1，相當于xavier = xavier + 1
++xzavier  //把變量累加1，相當于xavier = xavier + 1
xzavier--  //把變量累減1，相當于xavier = xavier - 1
--xzavier  //把變量累減1，相當于xavier = xavier - 1

上述代碼不只是++--前后置的區別，當有賦值操作時，區別為：

var xzavier = 1;
var num1 = ++xzavier; //num1 值為2   -- 第1點
var num2 = xzavier++; //num2 值為1   -- 第2點

對于第1點：

num1得到的值是 ++xzavier表達式的返回值，這個表達式返回xzavier自加1之后的值，這一點可以在控制臺打印來觀察。當然，xzavier變量也自加1，值也變為了2

對于第2點：

num2得到的值是 ++xzavier表達式的返回值，這個表達式返回xzavier本身的值（自加1之前的值），這一點可以在控制臺打印來觀察。之后++后置操作符對xzavier起作用，于是xzavier自加1，xzavier的值現在是2了。

也就是說，如果定義num1和num2之后的這個表達式返回值作用的優先級為R，那么++前置操作符作用的優先級是大于R的，而++后置操作符作用的優先級是小于R的。

加減運算符本應參與運算，但也可以進行類型轉換：

var xzavier1 = "xzavier", xzavier2 = "123", xzavier3 = false, xzavier4 = 123, xzavier5 = "-123";
+xzavier1  //NaN
+xzavier2  //123
+xzavier3  //0
+xzavier4  //123
+xzavier5  //-123
-xzavier1  //NaN
-xzavier2  //-123
-xzavier3  //0
-xzavier4  //-123
-xzavier5  //123

// 用+轉換規則手寫一個parseInt
function myParseInt(value) {
    if(typeof value === "number") {
        return value;
    }

    if(typeof value === "string" && value.length > 0) {
        value = value.match(/^d+/);
        if (Array.isArray(value)) {
            return +value[0];
        }
    }

    return NaN;
} 

當然，還有一些方法也可以被當做一元運算符，比如：

typeof 方法是一元運算符，可操作單個值，判斷類型。

delete 也是一元運算符， 它用來刪除對象屬性或者數組元素。

在運算時候如果運算值不是數值，那么后臺會先使用 Number() 轉型函數將其轉換為數值，隱式轉換：

加法

var xzavier = 123 + 456;     //579
var xzavier = 1 + NaN;       //NaN，只要運算中有一個NaN，計算值就為NaN
var xzavier = 123 + "abc";   //123abc  有字符串時未字符串連接符
var xzavier = 123 + Object;  //123[object Object]

對象會內部調用 toString() 或 valueOf() 方法進行轉換為原始值。（這里有提到 valueOf 和 toString 方法的轉換：JavaScript-數據類型淺析）

減法

var xzavier = 123 - 12; //111
var xzavier = -123 - 12 //-135
var xzavier = 123 - true; //122 true會隱式轉換為1
var xzavier = 123 - "xzavier"; //NaN

乘法

var xzavier = 123 * 2; //246
var xzavier = 123 * NaN; //NaN
var xzavier = 123 * true; //123
var xzavier = 123 * ""; //0

除法

var xzavier = 123 / 3; //41
var xzavier = 123 / 4; //30.75
var xzavier = 123 / NaN; //NaN
var xzavier = 123 / true; //123
var xzavier = 123 / ""; //Infinity

求余

var xzavier = 123 % 3; //0
var xzavier = 123 % 4; //3
var xzavier = 123 % NaN; //NaN
var xzavier = 123 % true; //0

用于比較的運算符稱作為關系運算符：小于 <、大于 >、小于等于 <=、大于等于 >=、相等 ==、不等 !=、全等(恒等) ===、不全等(不恒等) !==：

兩個操作數都是數值，則數值比較；

兩個操作數都是字符串，則比較兩個字符串對應的字符編碼值；

兩個操作數有一個是數值，則將另一個轉換為數值，再進行數值比較；

兩個操作數有一個是對象，則先調用 valueOf() 方法或 toString() 方法，再用結果比較。

321 > 123; //true
123 > 321; //false
"123" > 321; //false
"321" > "1234"; //true
"a" > "b"; //false a=97,b=98
"a" > "B"; //true B=66
1 > Object; //false

在相等和不等的比較上，如果操作數是非數值，則遵循一下規則：

一個操作數是布爾值，則比較之前將其轉換為數值，false 轉成 0，true 轉成 1；

一個操作數是字符串，則比較之前將其轉成為數值再比較；

一個操作數是對象，則先調用 valueOf() 或 toString() 方法后再和返回值比較；

不需要任何轉換的情況下，null 和 undefined 是相等的；

一個操作數是 NaN，則 == 返回 false，!= 返回 true；并且 NaN 和自身不等；

兩個操作數都是對象，則比較他們是否是同一個對象，如果都指向同一個對象，則返回 true，否則返回 false；

在全等和全不等的判斷上，只有值和類型都相等，才返回 true，否則返回 false。

123 == 123; //true
"123" == 123; //true，"123"會轉成成數值123
false == 0; //true，false 轉成數值就是0
"a" == "A"; //false，轉換后的編碼不一樣
123 == {}; //false，執行toString()或valueOf()會改變
123 == NaN; //false，只要有NaN，都是false
{} == {}; //false，比較的是他們的地址，每個新創建對象的引用地址都不同

null == undefined //true
"NaN" == NaN //false
123 == NaN //false
NaN == NaN //false
false == 0 //true
true == 1 //true
true == 2 //false
undefined == 0 //false
null == 0 //false
"123" == 123 //true
"123" === 123 //false

邏輯運算符通常用于布爾值的操作，一般和關系運算符配合使用，有三個邏輯運算符：

邏輯與（AND）：&&

num1 && num2
true    true    true
true    false   false
false   true    false
false   false   false

如果兩邊的操作數有一個操作數不是布爾值的情況下，與運算就不一定返回布爾值，此時，遵循已下規則：

第一個操作數是對象，則返回第二個操作數；

第二個操作數是對象，則第一個操作數返回 true，才返回第二個操作數，否則返回 false；

有一個操作數是 null，則返回 null；

有一個操作數是 undefined，則返回 undefined。

邏輯或（OR）：||

num1 || num2
true    true     true
true    false    true
false   true     true
false   false    false

如果兩邊的操作數有一個操作數不是布爾值的情況下，邏輯與運算就不一定返回布爾值，此時，遵循已下規則：

第一個操作數是對象，則返回第一個操作數；

第一個操作數的求值結果為 false，則返回第二個操作數；

兩個操作數都是對象，則返回第一個操作數；

兩個操作數都是 null，則返回 null；

兩個操作數都是 NaN，則返回 NaN；

兩個操作數都是 undefined，則返回 undefined。

邏輯非（NOT）：!

邏輯非參考： JavaScript數據判斷
邏輯非運算符可以用于任何值。無論這個值是什么數據類型，這個運算符都會返回一個布爾值。它的流程是：先將這個值轉換成布爾值，然后取反，規則如下：

操作數是一個對象，返回 false；

操作數是一個空字符串，返回 true；

操作數是一個非空字符串，返回 false；

操作數是數值 0，返回 true；

操作數是任意非 0 數值（包括 Infinity），false；

操作數是 null，返回 true；

操作數是 NaN，返回 true；

操作數是 undefined，返回 true。

不過，邏輯非也比較特殊?？梢愿玫挠洃洠?的判斷

var xzavier = !(123 > 12); //false
var xzavier = !{}; //false
var xzavier = !""; //true
var xzavier = !"xzavier"; //false
var xzavier = !0; //true
var xzavier = !123; //false
var xzavier = !null; //true
var xzavier = !NaN; //true
var xzavier = !undefined; //true

在一般的應用中，我們基本上用不到位運算符。位非 NOT ~、位與 AND &、位或 OR |、位異或 XOR ^、左移 <<、有符號右移 >>、無符號右移 >>>。

var xzavier = ~123; //-124
var xzavier = 123 & 3; //3
var xzavier = 123 | 3; //123
var xzavier = 123 << 3; //984
var xzavier = 123 >> 3; //15
var xzavier = 123 >>> 3; //15

過程勉強看一下哈，不想寫很多0101，所以寫在紙上O(∩_∩)O~

var xzavier = 123; //把123賦值給xzavier變量
xzavier = xzavier +123; //246

更多類似賦值運算符

乘/賦 *=

除/賦 /=

取余/賦 %=

加/賦 +=

減/賦 -=

左移/賦 <<=

有符號右移/賦 >>=

無符號右移/賦 >>>=

function absN(xzavier) {
    return xzavier > 0 ? xzavier : -xzavier;
}
absN(-123);  //123
absN(123);  //123

逗號運算符用于對兩個表達式求值，并返回后一個表達式的值。

"xza", "vier" // "vier"

var x = 0;
var y = (x++, 10);  
x // 1 
y // 10

. [] ()                          對象成員存取、數組下標、函數調用等
++ -- ~ ! delete new typeof void 一元運算符
乘法 / %                          乘法、除法、去模
加法 - +                          加法、減法、字符串連接
<< >> >>>                        位移
< <= > >= instanceof             關系比較、檢測類實例
== != === !==                    恒等(全等)
&                                位與
^                                位異或
|                                位或
&&                               邏輯與
||                               邏輯或
?:                               三元條件
= x=                             賦值、運算賦值
,                                多重賦值、數組元素分隔符
圓括號()可以用來提高運算的優先級，因為它的優先級是最高的，即圓括號中的表達式會第一個運算。

幾個有意思的等式：

[1,2] + [3,4] == "1,23,4";  //true
[4,[3,2]][7][0] == 3;  //true
++[[]][+[]]+[+[]] == "10";  //true

今天好天氣，打籃球去咯。代碼，籃球，生活...