摘要：一元操作符智能操作一個值的操作符叫做一元操作符。它們不僅適用于整數(shù)，也適用于字符串布爾值浮點數(shù)值和對象。此類操作符主要用于基本的算術(shù)運算。執(zhí)行按位非就是返回數(shù)字的反碼，就是操作數(shù)的負(fù)值。乘法用星號表示該操作符。

在ECMA-262 中，描述了一組用于操作數(shù)據(jù)值的操作符，包括算術(shù)操作符（如加減符號）、位操作符、關(guān)系操作符和相等操作符。

智能操作一個值的操作符叫做一元操作符。

此類操作符是借鑒于C 語言，有兩個版本，一種是前置型，一種是后置型。

在執(zhí)行前置型操作符時，變量的值都是在語句被求值以前改變的。（副效應(yīng)）如：

var num1 = 10;
var num2 = 20;
var num3 = --num1 + num2;
var num4 = num1 + num2;
document.write(num3 + " " + num4); //29 29
//由于是前置型遞減操作符,num3 在計算結(jié)果出來之前，num1 已經(jīng)是9 了，所以num3 的計算結(jié)果就是29；同樣的，由于計算num3 之后，num1 是9，所以num4 同樣是29。

區(qū)別就是符號放在變量的后面，以及操作符是在包含他們的語句求值之后才執(zhí)行的。如：

var num1 = 10;
var num2 = 20;
var num3 = num1-- + num2;
var num4 = num1 + num2;
document.write(num3 + " " + num4);//30 29
//由于是后置型遞減操作符，num3 在計算結(jié)果出來之后，num1 才變成9，所以num3 的計算結(jié)果仍然是30；同樣的，由于計算num3之后，num1才變成9，所以num4 則是29.

應(yīng)該注意的是，此類操作符對任何值都適用。它們不僅適用于整數(shù)，也適用于字符串、布爾值、浮點數(shù)值和對象。如：

var a = "12";
var b = "abc";
var c = true;
var d = 0.123;
var object = {
    valueOf: function(){
        return 1;
    }
}
document.write(++a); //13
document.write(++b); //NaN
document.write(++c); //2
document.write(++d); //1.123
document.write(++object); //2

此類操作符的作用與數(shù)學(xué)常識完全一樣，不再詳述。此類操作符主要用于基本的算術(shù)運算。

ECMAScript 中的所有數(shù)值都是以IEE-754 64 位格式儲存的，但位操作符并不直接操作64 位的值。而是先轉(zhuǎn)換成32 位，操作之后再存儲為64位。對于有符號的整數(shù)，32 位的前31 位用于表示整數(shù)的值。第32位用來表示數(shù)值的符號。0 為正，1 為負(fù)。這個表示符號的位就是符號位。

那么在JavaScript 中如何將數(shù)值或字符串轉(zhuǎn)換成二進(jìn)制字符串呢？如下：

var a = "18";
var numA = parseInt(a,10).toString(2);
document.write(numA); //10010

由波浪線（~）表示。執(zhí)行按位非就是返回數(shù)字的反碼，就是操作數(shù)的負(fù)值-1。如：

var a = "18";
var numA = parseInt(a,10).toString(2);
document.write(numA); //10010
document.write(~numA); //-10011
//這里，18 的二進(jìn)制碼就是10010，它的反碼就是-10011

轉(zhuǎn)換二進(jìn)制和十進(jìn)制的方法如下：

var a = "12";
var x = parseInt(a,10).toString(2);
document.write("這個數(shù)的二進(jìn)制碼是：" + x);
document.write("
");

var y = ~x;
document.write("這個數(shù)的二進(jìn)制反碼是：" + y);
document.write("
");

var b = parseInt(x,2).toString(10);
document.write("您輸入的數(shù)字是：" + b);

/*
這個數(shù)的二進(jìn)制碼是：1100
這個數(shù)的二進(jìn)制反碼是：-1101
您輸入的數(shù)字是：12
*/

用& 字號表示。簡單的說就是按位與操作只在兩個數(shù)值的對應(yīng)位都是1 時才返回1，任何一位是0，結(jié)果都是0.如：

var num1 = 25;
var num2 = 3;
document.write(num1 & num2) //1
//首先其底層操作實際上就是25 和3 的二進(jìn)制碼在對應(yīng)位都是1 時才返回1，其他都是0，所以結(jié)果就是十進(jìn)制1 的二進(jìn)制碼。

用| 豎線符號表示，簡單的說就是有一個位是1 的情況下就返回1，而只有在兩個位都是0 的情況下才返回0。如：

var num1 = 25;
var num2 = 3;
document.write(num1 | num2) //27

用^ 插入符號表示，簡單的說就是對應(yīng)位上只有一個1 時才返回1，如果對應(yīng)的兩位都是1 或都是0，則返回0。如：

var num1 = 25;
var num2 = 3;
document.write(num1 ^ num2) //26

用<< 兩個小于號來表示，這個操作符會將數(shù)值的所有位向左移動指定的位數(shù)。如：

var num1 = 2;
var num2 = num1 << 5;
document.write(num2); //64

用>> 兩個大于號來表示，但是保留符號位！如：

var num1 = -64;
var num2 = num1 >> 5;
document.write(num2); //2

用>>> 三個大于號來表示，這樣就沒有辦法保留符號位了！如：

var num1 = 64;
var num2 = num1 >>> 5;
document.write(num2); //2
//對于正數(shù)來說，結(jié)果依然還是原來的結(jié)果（保留符號位）

var num1 = -64;
var num2 = num1 >>> 5;
document.write(num2); //134217726
//但是對于負(fù)數(shù)，結(jié)果就不同了（不保留符號位）

主要用來執(zhí)行if...else 等循環(huán)之類的語句。包括邏輯非（!）、邏輯與（&&）以及邏輯或（||）

用! 嘆號表示。主要規(guī)則如下：

如果操作數(shù)是對象，返回false；

如果操作數(shù)是空字符串，返回true；

如果操作數(shù)是數(shù)值0，返回true，非零（包括infinity），返回false；

如果操作數(shù)是null、NaN、undefined，返回true；

具體例子如下：

var obj = {};
document.write(!obj); //false
var str = "";
document.write(!str); //true
var num = Infinity;
document.write(!num); //false
var thing = NaN;
document.write(!thing); //true

用&& 兩個和號表示。主要規(guī)則如下：

如果第一個操作數(shù)是對象，則返回第二個操作數(shù)；

如果第一個操作數(shù)求值結(jié)果是true，且第二個操作數(shù)是對象，則返回第二個操作數(shù)；

如果兩個操作數(shù)都是對象，則返回第二個操作數(shù)；

如果有一個操作數(shù)是null、NaN或者undefined，則返回null、NaN或undefined；

具體例子如下：

var obj1 = {};
var obj2 = {name:"-helloworld-"};
var result1 = (obj1 && 321);
document.write(result1); //321 第一個是true 的對象，返回第二個操作數(shù)
var result2 = (!obj1 && 321);
document.write(result2); //false 第一個是false，沒有必要對321 求值
var result3 = (obj1 && obj2.name);
document.write(result3); //"-helloworld-" 第一個是true 的對象，返回第二個對象的操作數(shù)
var result4 = (321 && 33);
document.write(result4); //第一個為true，返回第二個操作數(shù)
var result5 = (321 && null);
document.write(result5); //第一個為true，返回null

值得注意的是，如果第一個操作數(shù)能夠決定結(jié)果，那么就不會對第二個操作數(shù)求值。如：

var x = true;
var y = {name:"helloworld"};
var result = (x && y.name);
document.write(result); //"helloworld" 第一個操作數(shù)不能判定結(jié)果，要繼續(xù)執(zhí)行下一個操作數(shù)，才能執(zhí)行document.write

var x = true;
var result = (x && z);
document.write(result); //由于z 沒有被定義，這里會發(fā)生錯誤，不會執(zhí)行document.write

var x = false;
var y = {name:"helloworld"};
var result = (x && y.name);
document.write(result); //false 第一個操作數(shù)能夠判定結(jié)果，不需要執(zhí)行下一個操作數(shù)，就可以直接執(zhí)行document.write

var x = false;
var result = (x && z);
document.write(result); //false 第一個操作數(shù)能夠判定結(jié)果，不需要執(zhí)行下一個操作數(shù)，所以無論下一個操作數(shù)是否被定義，不會發(fā)生錯誤。都可以直接執(zhí)行document.write

用|| 兩個豎線符號表示。主要規(guī)則如下：

如果第一個操作數(shù)是對象，則返回第一個操作符；

如果第一個操作數(shù)的求值結(jié)果是false，則返回第二個操作數(shù)；

如果兩個操作數(shù)都是對象，則返回第一個操作數(shù)；

如果兩個操作數(shù)都是null、NaN或者undefined，則返回null、NaN或undefined；

值得注意的是，如果第一個操作數(shù)的求值結(jié)果是true，就不會對第二個操作數(shù)求值了。如：

var x = true;
document.write(x || z); //true 雖然這里并沒有定義z 但是由于第一個操作數(shù)能夠判定結(jié)果，則不需要繼續(xù)對第二個操作符進(jìn)行求值

var x = false;
document.write(x || z);
document.write("false"); //這里之所以不會返回false，是因為在第一個操作數(shù)判定不了結(jié)果的情況下，會對第二個操作數(shù)進(jìn)行求值，但是第二個操作數(shù)未定義。所以會出現(xiàn)錯誤。

另外，還需要注意的是，我們可以利用邏輯或的這一行為來避免為變量賦予null 或 undefined 值。例如：

var str1 = "hello there!";
var str2 = null;
var str = str2 || str1;
document.write(str);
str2 = undefined;
var str = str2 || str1;
document.write(str);
//這樣就能規(guī)避其中一個操作數(shù)是null 或者undefined，把第二個操作數(shù)作為后備值

ECMAScript 定義了3個乘性操作符：乘法、除法和求模。

用* 星號表示該操作符。

主要規(guī)則有：

如果計算結(jié)果超過了表示范圍，則會返回+/-Infinity；

如果有一個操作數(shù)是NaN，則結(jié)果是NaN。

如果是Infinity 與0 相乘，則結(jié)果是NaN。

如果Infinity 與 Infinity 相乘，則結(jié)果是+/-Infinity；

如果其中一個操作數(shù)不是數(shù)值，后臺將會先用Number()對齊進(jìn)行轉(zhuǎn)換，然后按照上面的規(guī)則求值。

具體例子：

var result = (-Number.MAX_VALUE * Number.MAX_VALUE)
document.write(result) //-Infinity
result = (NaN * 321);
document.write(result) //NaN
result = (-Infinity * 0);
document.write(result) //NaN
result = (Infinity * -Infinity);
document.write(result) //=Infinity
result = (1 * "321");
document.write(result) //321
result = (1 * false);
document.write(result) //0

用/ 斜線符號表示。

主要規(guī)則如下：

如果計算結(jié)果超過了表示范圍，則會返回+/-Infinity；

如果有一個操作數(shù)是NaN，則結(jié)果是NaN；

如果是0 除以0，結(jié)果則是NaN；

如果是非零的有限數(shù)被0 除，結(jié)果是+/-Infinity；

如果是Infinity 被任何非零數(shù)值除，結(jié)果則是+/-Infinity；

具體例子如下：

var result = (Number.MAX_VALUE / Number.MIN_VALUE);
document.write(result) //Infinity
result = (NaN / Number.MIN_VALUE);
document.write(result) //NaN
result = (0 / 0);
document.write(result) //NaN
result = (-421 / 0);
document.write(result) //-Infinity
result = (-Infinity / 2);
document.write(result) //-Infinity

用% 百分號表示，求模就是求余數(shù)。

主要規(guī)則如下：

如果被除數(shù)是無窮大，除數(shù)是有限大，則返回NaN；

如果被除數(shù)是有限大，除數(shù)是0，則返回NaN；

Infinity 除以Infinity 結(jié)果是NaN；

被除數(shù)是有限大，除數(shù)是無窮大，結(jié)果是除數(shù)；

被除數(shù)如果是0，結(jié)果就是0；

如果其中一個操作數(shù)不是數(shù)值，則后臺先轉(zhuǎn)換成數(shù)值再進(jìn)行上述規(guī)則。

具體例子如下：

var result = (Infinity % 2);
document.write(result) //NaN
var result = (2 % 0);
document.write(result) //NaN
var result = (Infinity % Infinity);
document.write(result) //NaN
var result = (2 % Infinity);
document.write(result) //2
var result = (0 % 2);
document.write(result) //0

用+ 加號表示，規(guī)則如下：

如果一個操作數(shù)是NaN，則結(jié)果是NaN；

如果是Infinity 加-Infinity，結(jié)果是NaN；

如果是Infinity 加Infinity，結(jié)果是Infinity；

如果是-Infinity 加-Infinity，結(jié)果是-Infinity；

如果是+0 加-0，結(jié)果是+0；

如果是+0 加+0，結(jié)果是+0；

如果是-0 加-0，結(jié)果是-0；

如果兩個操作數(shù)都是字符串，則拼接兩個字符串；

如果只有一個操作數(shù)是字符串，則將另一個轉(zhuǎn)換成字符串再拼接起來；

具體例子如下：

var num1 = NaN;
var num2 = Infinity;
var result = num1 + num2;
document.write(result); //NaN
var num1 = Infinity;
var num2 = -Infinity;
var result = num1 + num2;
document.write(result); //NaN
var num1 = Infinity;
var num2 = Infinity;
var result = num1 + num2;
document.write(result); //Infinity;
var num1 = -Infinity;
var num2 = -Infinity;
var result = num1 + num2;
document.write(result); //-Infinity
var num1 = "hello ";
var num2 = "there";
var result = num1 + num2;
document.write(result); //"hello there"
var num1 = 1000;
var num2 = " there";
var result = num1 + num2;
document.write(result); //"1000 there"
var result_num = parseInt(result);
document.write(result_num);//可以證明result 是字符串

值得注意的是，加性操作符在編程中的常見的錯誤：

var num1 = 11;
var num2 = 100;
document.write("the result is " + num1 + num2); //"the result is 11100" 錯誤，num1 和num2 被拼接成字符串
document.write("the result is " + (num1 + num2)); //“the result is 111” 正確，括號內(nèi)的為計算值

用- 減號表示，規(guī)則如下：

如果一個操作數(shù)是NaN，結(jié)果是NaN；

如果Infinity 減Infinity，結(jié)果是NaN；

如果-Infinity 減-Infinity，結(jié)果是NaN；

如果Infinity 減-Infinity，結(jié)果是Infinity；

如果-Infinity 減Infinity，結(jié)果是-Infinity；

如果是+0 減+0，結(jié)果是+0；

如果是+0 減-0，結(jié)果是-0；

如果是-0 減-0，結(jié)果是+0；

如果有一個操作數(shù)是字符串、布爾值、null 或undefined，則后臺會先把它轉(zhuǎn)換成數(shù)值；

具體例子如下：

document.write(3 - null); //3
document.write(NaN - true); //NaN
document.write(3 - ""); //3
document.write(3 - "1"); //2
document.write(Infinity - Infinity); //NaN
document.write(-Infinity - Infinity); //-Infinity

用< 小于、> 大于、<= 小于等于、>= 大于等于表示。規(guī)則是：

如果兩個操作數(shù)都是字符串，則比較兩個字符串對應(yīng)的字符編碼值；

如果一個操作數(shù)是數(shù)值，則將另一個操作數(shù)轉(zhuǎn)換成一個數(shù)值再比較；

如果一個操作數(shù)是數(shù)值，則將另一個操作數(shù)轉(zhuǎn)換成一個數(shù)值，當(dāng)不能轉(zhuǎn)換成數(shù)值時，會當(dāng)做NaN 進(jìn)行比較，但是與NaN 進(jìn)行比較的結(jié)果都是false；

大寫字母的字符編碼全部小于小寫字符編碼；

具體例子如下：

document.write("Blackbarry" < "apple"); //true 大寫字母字符編碼小于小寫字符編碼
document.write("blackbarry" < "apple"); //false
document.write("10" < "3"); //true 兩個都是字符串 所以比較的是字符編碼
document.write("10" < 3); //false “10”字符串被轉(zhuǎn)換成10 數(shù)值，比較數(shù)值大小
document.write("a" < 3); //false "a"字符串被轉(zhuǎn)換成了NaN，任何操作數(shù)與NaN 比較都是false；

用== 表示相等、!= 不等、=== 全等、 !==不全等。

規(guī)則如下：

null 和undefined 是相等的

如果一個操作數(shù)是NaN，相等則返回false，不等則返回true。如果兩個操作符都是NaN，相等還是返回false，因為NaN 與NaN 不相等；

如果兩個操作數(shù)都是對象，則比較他們是不是同一個對象；

具體例子如下：

document.write(null == undefined); //true
document.write(null == NaN); //false
document.write(NaN == NaN); //false
document.write("NaN" == NaN); //false
document.write("null" == undefined); //false
document.write(0 == undefined); //false
document.write(0 != "0"); //false
document.write(0 != false); //false

與相等和不等類似，例子如下：

document.write(undefined === null); //false 兩個是不同類型的值
document.write(undefined == null); //true 兩個是不同類型的值 但相等 不全等
document.write("21" == 21); //true
document.write("21" === 21); //false

千萬注意null 和undefined 是相等但不全等

語法形式是：

變量 = 條件 ？ true : false;

舉個例子：

var num1 = 10;
var num2 = 30;
var num = (num1 > num2) ? num1 : num2;
document.write(num); //30 選擇最大的那個賦值給變量并打印出來

用= 等號來表示，另外，復(fù)合賦值操作還可以用復(fù)合賦值操作符來表示。如：

var x = 10;
x = x + 1;
document.write(x); //11
//上面這種可以寫成下面這種
var x = 10;
x +=1;
document.write(x); //11
var x = 10;
x *=2;
document.write(x); //20

其他還有：

(*=)

(/=)

(%=)

(+=)

(-=)

(<<=)

(>>=)

(>>>=)

值得注意的是，使用上面這些并不能帶來任何性能的提升，無非是省了幾個字符

逗號操作符可以在一條語句中執(zhí)行多個操作，如：

var num1 = 1,
num2 = 2,
num3 = 3;
document.write(num1 + num2 + num3) //6

另外，逗號也可以用來賦值，逗號最后面的數(shù)值會被賦值到變量中。比如：

var x = (1,2,3,4,5);
document.write(x); //5
var x = (1,2,3,4,5,);
document.write(x); //出現(xiàn)錯誤