js 運算符(一) · 地表最強JS文檔

[TOC] # 每日單詞 1. `brown` 棕色 2. `lazy` 懶惰的 3. `Reference` 引用 4. `positive infinity`正無窮 5. `positive` 積極的 6. `negative` 消極 7. `negative infinity` 負無窮 # 一元操作符 ## 什么是一元運算符? > 只能操作一個值的操作符叫做一元操作符 #### 遞增和遞減操作符 ```javascript var age = 29; ++age; ``` ```javascript var age = 29; age = age + 1; ``` ```javascript var age = 29; --age; ``` ```javascript var age = 29; var anotherAge = --age + 2; console.log(age); console.log(anotherAge); ``` ```javascript var num1 = 2; var num2 = 20; var num3 = --num1 + num2; var num4 = num1 + num2; ``` ```javascript var a = 1; console.log(++a); // 2 console.log(a++); // 2 console.log(a); // 3 // console.log(a++); 相當于下面的代碼 console.log(a); // 3 a = a + 1; ``` ```javascript var a = 10; console.log(--a); // 9 console.log(a); // 9 console.log(a--); // 9 console.log(a); // 8 ``` ```javascript var age = 29; var anotherAge = --age + 2; console.log(age); // 28 console.log(anotherAge); // 30 ``` ```javascript var age = 29; // var anotherAge = age-- + 2; var anotherAge = age + 2; age = age - 1; console.log(age); // 28 console.log(anotherAge); // 31 ``` 后置型遞增和遞減操作符的語法不變（仍然分別是 ++ 和 -- ），只不過要放在變量的后面而不是前面。后置遞增和遞減與前置遞增和遞減有一個非常重要的區別，即遞增和遞減操作是在包含它們的語句被求值之后才執行的。這個區別在某些情況下不是什么問題，例如： ```javascript var age = 29; age++; ``` 把遞增操作符放在變量后面并不會改變語句的結果，因為遞增是這條語句的唯一操作。但是，當語句中還包含其他操作時，上述區別就會非常明顯了。 ```javascript var num1 = 2; var num2 = 20; var num3 = num1-- + num2; var num4 = num1 + num2; ``` ```javascript var num1 = 2; var num2 = 20; var num5 = 12; var num3 = ++num5 - num1-- + num2; var num4 = num1 + num2; console.log(num1); // 1 console.log(num2); // 20 console.log(num3); // 31 console.log(num4); // 21 ``` 所有這 4 個操作符對任何值都適用，也就是它們不僅適用于整數，還可以用于字符串、布爾值、浮點數值和對象。在應用于不同的值時，遞增和遞減操作符遵循下列規則。 #### 在應用于一個包含有效數字字符的字符串時，先將其轉換為數字值，再執行加減 1 的操作。字符串變量變成數值變量。 ```javascript var num1 = "123hello"; console.log(num1++); // NaN var num1 = "123"; console.log(num1++); // 123 console.log(++num1); // 125 ``` #### 在應用于一個不包含有效數字字符的字符串時，將變量的值設置為 NaN, 字符串變量變成數值變量。 ```javascript var num1 = "hello"; console.log(num1++); // NaN ``` ```javascript var num1 = "hello"; console.log(num1++); // NaN console.log(num1); // NaN console.log(typeof num1); // number ``` #### 在應用于布爾值 false 時，先將其轉換為 0 再執行加減 1 的操作。布爾值變量變成數值變量。 #### 在應用于布爾值 true 時，先將其轉換為 1 再執行加減 1 的操作。布爾值變量變成數值變量。 ```javascript var a = true; console.log(a++); // 1 console.log(++a); // 3 console.log(typeof a); // number ``` ```javascript var a = false; console.log(a++); // 0 console.log(++a); // 2 console.log(typeof a); // number ``` #### 在應用于浮點數值時，執行加減 1 的操作。 ```javascript var a = 1.11; console.log(a++); // 1.11 console.log(++a); // 3.1100000000000003 console.log(typeof a); // number ``` #### 在應用于對象時，先調用對象的 valueOf() 方法以取得一個可供操作的值。然后對該值應用前述規則。如果結果是 NaN ，則在調用 toString() 方法后再應用前述規則。對象變量變成數值變量。 ```javascript var a = []; console.log(a++); // 0 console.log(++a); // 2 console.log(typeof a); // number var b = {}; console.log(b++); // NaN console.log(++b); // NaN console.log(typeof b); // number ``` ```javascript var s1 = "2"; var s2 = "z"; var b = false; var f = 1.1; var o = { valueOf: function() { return -1; } }; s1++; s2++; b++; f--; o--; // console.log(s1); //3 // console.log(s2); // NaN // console.log(b); // 1 // console.log(f); // 0.10000000000000009 console.log(o); //-2 ``` 2. 一元加和減操作符 ```javascript var num = 25; num = +num; ``` 不過，在對非數值應用一元加操作符時，該操作符會像 Number() 轉型函數一樣對這個值執行轉換。換句話說，布爾值 false 和 true 將被轉換為 0 和 1，字符串值會被按照一組特殊的規則進行解析，而對象是先調用它們的 valueOf() 和（或） toString() 方法，再轉換得到的值。下面的例子展示了對不同數據類型應用一元加操作符的結果： ```javascript 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 轉換成-1 ```javascript var num = 25; num = -num; // 變成了-25 ``` 在將一元減操作符應用于數值時，該值會變成負數。而當應用于非數值時，一元減操作符遵循與一元加操作符相同的規則，最后再將得到的數值轉換為負數， ```javascript 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; s2 = +s2; s3 = +s3; b = +b; f = +f; o = +o; console.log(s1); // 1 console.log(s2); // 1.1 console.log(s3); // NaN console.log(b); // 0 console.log(f); // 1.1 console.log(o); // -1 ``` # 位操作符(不講...)pass # 布爾操作符在一門編程語言中，布爾操作符的重要性堪比相等操作符。如果沒有測試兩個值關系的能力，那么諸如 if...else 和循環之類的語句就不會有用武之地了。布爾操作符一共有 3 個：非（NOT）、與/且（AND）和或（OR）。 ## 邏輯非邏輯非操作符由一個嘆號（！）表示，可以應用于 ECMAScript 中的任何值。無論這個值是什么數據類型，這個操作符都會返回一個布爾值。邏輯非操作符首先會將它的操作數轉換為一個布爾值，然后再對其求反。也就是說，邏輯非操作符遵循下列規則： #### 如果操作數是一個對象，返回 false ； #### 如果操作數是一個空字符串，返回 true ； ```javascript var a = {}; console.log(!a); // false var b = ""; console.log(!b); // true ``` #### 如果操作數是一個非空字符串，返回 false ； ```javascript var b = "the quick brown fox jumps over the lazy dog"; console.log(!b); // false ``` #### 如果操作數是數值 0，返回 true ； ```javascript console.log(!0); // true console.log(Boolean(0)); // false ``` #### 如果操作數是任意非 0 數值（包括 Infinity ），返回 false ； ```javascript console.log(!123123); // false console.log(Boolean(123123)); // true console.log(!1.7976931348623157e30899); // false infinity ``` #### 如果操作數是 null ，返回 true ； ```javascript console.log(!null); // true console.log(Boolean(null)); // false ``` #### 如果操作數是 NaN ，返回 true ； ```javascript console.log(!NaN); // true console.log(Boolean(NaN)); // false ``` #### 如果操作數是 undefined ，返回 true 。 ```javascript console.log(!undefined); // true console.log(Boolean(undefined)); // false ``` ```javascript console.log(!false); // true console.log(!"blue"); // false console.log(!0); // true console.log(!NaN); // true console.log(!""); // true console.log(!12345); // false ``` 邏輯非操作符也可以用于將一個值轉換為與其對應的布爾值。而同時使用兩個邏輯非操作符，實際上就會模擬 Boolean() 轉型函數的行為。其中，第一個邏輯非操作會基于無論什么操作數返回一個布爾值，而第二個邏輯非操作則對該布爾值求反，于是就得到了這個值真正對應的布爾值。當然，最終結果與對這個值使用 Boolean() 函數相同 ```javascript console.log(!!"blue"); // true console.log(!!0); // false console.log(!!NaN); // false console.log(!!""); // false console.log(!!12345); // true ``` ## 邏輯與 > 兩個真, 才為真. 第一個錯了,就不往下跑了, 輸出第一個;若第一個正確, 則不論第二個正確與否, 輸出第二個. 邏輯與操作符由兩個和號（ && ）表示，有兩個操作數，如下面的例子所示： ```javascript var result = true && false; ``` 邏輯與的真值表如下： | 第一個操作數 | 第二個操作數 | 結果 | | ------------ | ------------ | ----- | | true | true | true | | true | false | false | | false | true | false | | false | false | false | 邏輯與操作可以應用于任何類型的操作數，而不僅僅是布爾值。在有一個操作數不是布爾值的情況下，邏輯與操作就不一定返回布爾值；此時，它遵循下列規則： #### 如果第一個操作數是對象，則返回第二個操作數； ```javascript var res = {} && "hello"; console.log(res); // hello ``` #### 如果第二個操作數是對象，則只有在第一個操作數的求值結果為 true 的情況下才會返回該對象； ```javascript var res = true && {}; console.log(res); // {} var res1 = false && {}; console.log(res1); // false var res2 = "hello" && {}; console.log(Boolean("hello")); // true console.log(res2); // {} ``` ```javascript var res3 = "" && {}; console.log(Boolean("")); // false console.log(res3); // "" ``` #### 如果兩個操作數都是對象，則返回第二個操作數； ```javascript console.log({ sex: "female" } && { age: 17 }); // { age: 17 } ``` 1. 如果有一個操作數是 null,一個平常值，則返回 null ； 1. 如果有一個操作數是 undefined,一個平常值，則返回 undefined 。 1. 如果有一個操作數是 NaN,一個平常值，則返回 NaN 。 ```javascript console.log(Boolean(null)); // false console.log(null && { age: 17 }); // null console.log(Boolean(undefined)); // false console.log(undefined && { age: 17 }); // undefined ``` ```javascript console.log(Boolean(NaN)); // false console.log(NaN && { age: 17 }); // NaN ``` 邏輯與操作屬于短路操作，即如果第一個操作數能夠決定結果，那么就不會再對第二個操作數求值。對于邏輯與操作而言，如果第一個操作數是 false ，則無論第二個操作數是什么值，結果都不再可能是 true 了 ```javascript var found = true; var result = found && someUndefinedVariable; console.log(result); // ReferenceError: someUndefinedVariable is not defined ``` ```javascript var found = false; var result = found && someUndefinedVariable; console.log(result); // false ``` ## 邏輯或邏輯或操作符由兩個豎線符號（ || ）表示，有兩個操作數，如下面的例子所示： ```javascript var result = true || false; ``` 邏輯或的真值表如下： | 第一個操作數 | 第二個操作數 | 結果 | | ------------ | ------------ | ----- | | True | true | true | | True | false | true | | false | true | true | | false | false | false | 與邏輯與操作相似，如果有一個操作數不是布爾值，邏輯或也不一定返回布爾值；此時，它遵循下列規則： #### 如果第一個操作數是對象，則返回第一個操作數 ```javascript console.log({} || "1123"); // {} ``` #### 如果第一個操作數的求值結果為 false ，則返回第二個操作數； ```javascript console.log(false || "1123"); // 1123 ``` #### 如果兩個操作數都是對象，則返回第一個操作數； ```javascript console.log({ sex: "female" } || { age: 17 }); // { sex: 'female' } ``` #### 如果兩個操作數都是 null ，則返回 null ； ```javascript console.log(null || null); // null ``` #### 如果兩個操作數都是 NaN ，則返回 NaN ； #### 如果兩個操作數都是 undefined ，則返回 undefined 。 ```javascript console.log(null || null); // null console.log(undefined || undefined); // undefined console.log(NaN || NaN); // NaN console.log(undefined || null); // null ``` 與邏輯與操作符相似，邏輯或操作符也是短路操作符。也就是說，如果第一個操作數的求值結果為 true ，就不會對第二個操作數求值了。下面看一個例子： ```javascript var found = true; var result = found || someUndefinedVariable; console.log(result); ``` ```javascript var found = false; var result = found || someUndefinedVariable; console.log(result); ``` 我們可以利用邏輯或的這一行為來避免為變量賦 null 或 undefined 值。例如： var myObject = preferredObject || backupObject; 在這個例子中，變量 myObject 將被賦予等號后面兩個值中的一個。變量 preferredObject 中包含優先賦給變量 myObject 的值，變量 backupObject 負責在 preferredObject 中不包含有效值的情況下提供后備值。如果 preferredObject 的值不是 null ，那么它的值將被賦給 myObject ；如果是 null ，則將 backupObject 的值賦給 myObject 。ECMAScript 程序的賦值語句經常會使用這種模式 ```javascript var preferredObject, backupObject; preferredObject = ""; backupObject = "USA"; var myObject = preferredObject || backupObject; console.log(myObject); // USA ``` # 乘性操作符 ECMAScript 定義了 3 個乘性操作符：乘法、除法和求模。如果參與乘性計算的某個操作數不是數值，后臺會先使用 Number() 轉型函數將其轉換為數值。也就是說，空字符串將被當作 0，布爾值 true 將被當作 1。 ## 乘法乘法操作符由一個星號（ \* ）表示，用于計算兩個數值的乘積。 ```javascript var result = 34 * 56; ``` 在處理特殊值的情況下，乘法操作符遵循下列特殊的規則： #### 如果操作數都是數值，執行常規的乘法計算，即兩個正數或兩個負數相乘的結果還是正數，而如果只有一個操作數有符號，那么結果就是負數。如果乘積超過了 ECMAScript 數值的表示范圍，則返回 Infinity 或 -Infinity ； ```javascript var a = Number.MAX_VALUE + 100; var b = Number.MAX_VALUE + 1001; console.log(a * b); // Infinity console.log(a * -b); // -Infinity ``` #### 如果有一個操作數是 NaN ，則結果是 NaN ； ```javascript console.log(NaN * 100); // NaN console.log(NaN * NaN); // NaN console.log(NaN - NaN); // NaN console.log(NaN + NaN); // NaN ``` #### 如果是 Infinity 與 0 相乘，則結果是 NaN ； ```javascript console.log(Number.MAX_VALUE * 100 * 0); // NaN console.log(Number.MAX_VALUE * 10); // Infinity ``` #### 如果是 Infinity 與非 0 數值相乘，則結果是 Infinity 或 -Infinity ，取決于有符號操作數的符號； ```javascript console.log(Number.MAX_VALUE * 10 * -1); // -Infinity console.log(Number.MAX_VALUE * 10 * 10); // Infinity ``` #### 如果是 Infinity 與 Infinity 相乘，則結果是 Infinity ； ```javascript console.log(Number.MAX_VALUE * 10 * (Number.MAX_VALUE * 10)); // Infinity console.log(Number.MAX_VALUE * 10 + Number.MAX_VALUE * 10); // Infinity console.log(Number.MAX_VALUE * 10 - Number.MAX_VALUE * 10); // NaN console.log((Number.MAX_VALUE * 10) / (Number.MAX_VALUE * 10)); // NaN ``` #### 如果有一個操作數不是數值，則在后臺調用 Number() 將其轉換為數值，然后再應用上面的規則。 ```javascript console.log([] * 100); // 0 console.log({} * 100); // NaN console.log(Number([1, 2, 3])); // NaN console.log([1, 2, 3] * 100); // NaN ``` #### 如果是 boolean 值, 會轉成 0 或者 1, true==>1, false==>0 ## 除法除法操作符由一個斜線符號（/）表示，執行第二個操作數除第一個操作數的計算 ```Javascript var result = 66 / 11; ``` 與乘法操作符類似，除法操作符對特殊的值也有特殊的處理規則。這些規則如下： #### 如果操作數都是數值，執行常規的除法計算，即兩個正數或兩個負數相除的結果還是正數，而如果只有一個操作數有符號，那么結果就是負數。如果商超過了 ECMAScript 數值的表示范圍，則返回 Infinity 或 -Infinity ； ```javascript console.log((Number.MAX_VALUE * 10) / 100); // Infinity console.log((Number.MAX_VALUE * 10) / -100); // -Infinity ``` #### 如果有一個操作數是 NaN ，則結果是 NaN ； ```javascript console.log((Number.MAX_VALUE * 10) / NaN); // NaN console.log(NaN / 0); // NaN ``` #### 如果是 Infinity 被 Infinity 除，則結果是 NaN ； ```javascript console.log(((Number.MAX_VALUE * 10) / Number.MAX_VALUE) * 100); // Infinity ``` ```javascript console.log(((Number.MAX_VALUE * 10) / Number.MAX_VALUE) * 100); // Infinity console.log((Number.MAX_VALUE * 10) / (Number.MAX_VALUE * 100)); // NaN console.log(Number.MAX_VALUE); // 1.7976931348623157e+308 console.log(Number.MAX_VALUE * 10); // Infinity ``` #### 如果是零被零除，則結果是 NaN ； ```javascript console.log(0 / 0); // NaN ``` #### 如果是非零的有限數被零除，則結果是 Infinity 或 -Infinity ，取決于有符號操作數的符號； ```javascript console.log(123 / 0); // Infinity console.log(0 / 123); // 0 ``` ```javascript console.log(-123 / 0); // -Infinity ``` #### 如果是 Infinity 被任何非零數值除，則結果是 Infinity 或 -Infinity ，取決于有符號操作數的符號； ```javascript console.log((Number.MAX_VALUE * 10) / 123); // Infinity console.log((Number.MAX_VALUE * 10) / 0); // Infinity console.log(1 / 0); // Infinity ``` #### 如果有一個操作數不是數值，則在后臺調用 Number() 將其轉換為數值，然后再應用上面的規則。 ```javascript console.log(1 / []); // Infinity ``` ```javascript console.log(1 / []); // Infinity console.log(1 / [1, 2, 3, 4]); // NaN console.log(1 / {}); // NaN console.log(1 / { sex: "male" }); // NaN ``` #### 如果是 boolean 值, 會轉成 0 或者 1, true==>1, false==>0 ```javascript console.log(1 * true); // 1 console.log(1 / true); // 1 console.log(1 * false); // 0 console.log(1 / false); // infinity ``` ## 求模 ```Javascript var result = 26 % 5; ``` ```javascript var num = 26 % 5; console.log(num); // 1 console.log(parseInt(26 / 5)); // 5 console.log(26 / 5); // 5.2 ``` 與另外兩個乘性操作符類似，求模操作符會遵循下列特殊規則來處理特殊的值： #### 如果操作數都是數值，執行常規的除法計算，返回除得的余數； #### 如果被除數是無窮大值而除數是有限大的數值，則結果是 NaN ； ```javascript console.log((Number.MAX_VALUE * 10) % 123); // NaN ``` #### 如果被除數是有限大的數值而除數是零，則結果是 NaN ； ```javascript console.log(10 % 0); // NaN ``` #### 如果是 Infinity 被 Infinity 除，則結果是 NaN ； ```javascript console.log((Number.MAX_VALUE * 10) % (Number.MAX_VALUE * 10)); // NaN ``` #### 如果被除數是有限大的數值而除數是無窮大的數值，則結果是被除數； ```javascript console.log(123 % (Number.MAX_VALUE * 10)); // 123 ``` #### 如果被除數是零，則結果是零； ```javascript console.log(0 % 123); //0 console.log(0 % (Number.MAX_VALUE * 10)); //0 ``` #### 如果有一個操作數不是數值，則在后臺調用 Number() 將其轉換為數值，然后再應用上面的規則。 #### 0 % 0 是 NaN ```javascript console.log([] % (Number.MAX_VALUE * 10)); //0 ``` ```javascript console.log([] % (Number.MAX_VALUE * 10)); //0 console.log([1, 2, 3] % (Number.MAX_VALUE * 10)); //NaN console.log({} % (Number.MAX_VALUE * 10)); //NaN console.log({ sex: "male" } % (Number.MAX_VALUE * 10)); //NaN ``` # 加性操作符 ## 加法加法操作符（+）的用法如下所示： ```javascript var result = 1 + 2; ``` 如果兩個操作符都是數值，執行常規的加法計算，然后根據下列規則返回結果： #### 如果有一個操作數是 NaN ，則結果是 NaN ； ```javascript console.log(NaN + 1); // NaN ``` #### 如果是 Infinity 加 Infinity ，則結果是 Infinity ； #### 如果是 -Infinity 加 -Infinity ，則結果是 -Infinity ； #### 如果是 Infinity 加 -Infinity ，則結果是 NaN ； ```javascript console.log(Number.MAX_VALUE * 10 + Number.MAX_VALUE * 10); // infinity console.log(-Infinity + -Infinity); // -Infinity console.log(-1 + -1); // -2 console.log(-Infinity + Infinity); // NaN ``` #### 如果是+0 加+0，則結果是+0； #### 如果是-0 加-0，則結果是-0； #### 如果是+0 加-0，則結果是+0。 ```javascript console.log(+0 + +0); // 0 console.log(-0 + -0); // -0 console.log(-0 + +0); // 0 console.log(+0); // 0 ``` 不過，如果有一個操作數是字符串，那么就要應用如下規則： #### 如果兩個操作數都是字符串，則將第二個操作數與第一個操作數拼接起來； #### 如果只有一個操作數是字符串，則將另一個操作數轉換為字符串，然后再將兩個字符串拼接起來。 ```javascript console.log("I love" + " China"); // I love China console.log("I love" + 123); // I love123 console.log(123 + "I love"); // 123I love console.log(typeof (123 + "")); // string ``` #### 如果有一個操作數是對象、數值或布爾值，則調用它們的 toString() 方法取得相應的字符串值然后再應用前面關于字符串的規則。 ```javascript console.log({} + {}); // "[object Object][object Object]" console.log({}.toString() + {}.toString()); // "[object Object][object Object]" console.log(typeof {}.toString()); // string console.log({}.toString()); // "[object Object]" ``` ```javascript console.log("I lvoe" + [] + "China"); // I lvoeChina console.log("I lvoe" + [1, 2, 3] + "China"); // I lvoe1,2,3China console.log([].toString()); // "" console.log([1, 2, 3].toString()); // 1,2,3 ``` #### 對于 undefined 和 null ，則分別調用 String() 函數并取得字符串 "undefined" 和 "null" 。 ```javascript console.log("hello" + undefined); // "helloundefined" console.log("hello" + null); // "hellonull" console.log("hello" + NaN); // "helloNaN" console.log(undefined + "hello"); // "undefinedhello" console.log(null + "hello"); // "nullhello" console.log(NaN + "hello"); // "NaNhello" ``` ```javascript var result1 = 5 + 5; // 兩個數值相加 console.log(result1); // 10 ``` ```javascript var result2 = 5 + "5"; // 一個數值和一個字符串相加 console.log(result2); // "55" ``` ```javascript var num1 = 5; var num2 = 10; var message = "The sum of 5 and 10 is " + num1 + num2; console.log(message); // "The sum of 5 and 10 is 510" ``` ```javascript var num1 = 5; var num2 = 10; var message = "The sum of 5 and 10 is " + (num1 + num2); console.log(message); //"The sum of 5 and 10 is 15" ``` ```Javasript var result1 = 5 + 5; console.log(result1); // 10 var result2 = 5 + "5"; console.log(result2); // 55 var num1 = 5; var num2 = 10; var message = "The sum of 5 and 10 is " + num1 + num2; // The sum of 5 and 10 is 510 var message = "The sum of 5 and 10 is " + (num1 + num2); // The sum of 5 and 10 is 15 var message = "The sum of 5 and 10 is " + 15; // The sum of 5 and 10 is 15 console.log(message); // The sum of 5 and 10 is 15 ``` ## 減法 ```javascript var result = 2 - 1; ``` #### 如果兩個操作符都是數值，則執行常規的算術減法操作并返回結果； #### 如果有一個操作數是 NaN ，則結果是 NaN ； ```javascript console.log("hello" - "hello"); // NaN ``` #### 如果是 Infinity 減 Infinity ，則結果是 NaN ； #### 如果是 -Infinity 減 -Infinity ，則結果是 NaN ； #### 如果是 Infinity 減 -Infinity ，則結果是 Infinity ； #### 如果是 -Infinity 減 Infinity ，則結果是 -Infinity ； ```javascript console.log(Infinity - Infinity); // NaN console.log(-Infinity - -Infinity); // NaN console.log(Infinity - Infinity); // NaN console.log(Infinity - -Infinity); // Infinity console.log(-Infinity - Infinity); // -Infinity ``` #### 如果是+0 減+0，則結果是+0； #### 如果是+0 減-0，則結果是+0； #### 如果是-0 減-0，則結果是+0； ```javascript // 如果是+0 減+0，則結果是+0； console.log(+0 - +0); // 0 // 如果是+0 減-0，則結果是0； console.log(+0 - -0); //0 // 如果是-0 減-0，則結果是+0； console.log(-0 - -0); //0 ``` #### 如果有一個操作數是字符串、布爾值、 null 或 undefined ，則先在后臺調用 Number() 函數將其轉換為數值，然后再根據前面的規則執行減法計算。如果轉換的結果是 NaN ，則減法的結果就是 NaN ； #### 如果有一個操作數是對象，則調用對象的 valueOf() 方法以取得表示該對象的數值。如果得到的值是 NaN ，則減法的結果就是 NaN 。如果對象沒有 valueOf() 方法，則調用其 toString()方法并將得到的字符串轉換為數值。 ```javascript console.log(true - false); // 1 console.log(null - false); // 0 console.log(undefined - false); // NaN console.log(Number(null)); // 0 console.log(Number(undefined)); // NaN ``` ```javascript var result1 = 5 - true; // 4，因為 true 被轉換成了 1 var result2 = NaN - 1; // NaN var result3 = 5 - 3; // 2 var result4 = 5 - ""; // 5，因為"" 被轉換成了 0 var result5 = 5 - "2"; // 3，因為"2"被轉換成了 2 var result6 = 5 - null; // 5，因為 null 被轉換成了 0 ``` ```javascript console.log("123" - "456"); //-333 console.log("123mm" - "456nn"); //NaN ``` ```javascript console.log("123" - []); //123 console.log("123" - [1, 2, 3]); //NaN console.log("123" - {}); //NaN console.log("123" - { sex: "male" }); //NaN ```