《JavaScript 闖關記》之表達式和運算符

表達式

表達式是由數字、運算符、數字分組符號（如括號）、自由變量和約束變量等以能求得數值的有意義排列方法所得的組合。JavaScript 表達式主要有以下幾種形式：

• 原始表達式：常量、變量、保留字。
• 對象、數組初始化表達式：var obj={a:1,b:2};，var arr=[1,2,3];。
• 函數定義表達式：var fn=function(){}。
• 屬性訪問表達式：Math.abs。
• 調用表達式：alert('hello');。
• 對象創建表達式：new object();。

運算符

JavaScript 中的運算符用於算術表達式、比較表達式、邏輯表達式、賦值表達式等。需要注意的是，大多數運算符都是由標點符號表示的，比如 + 和 =。而另外一些運算符則是由關鍵字表示的，比如 typeof 和 instanceof，關鍵字運算符和標點符號都是正規的運算符。

下表列出了 JavaScript 中所有的運算符，並按照運算符的優先級排序的，前面的運算符優先級要高於後面的運算符優先級，被空行分隔開來的運算符具有不同的優先級。標題爲 A 的列表示運算符的結合性（Associativity），L 表示從左至右、R 表示從右至左，標題爲 N 的列表示操作數的個數（Number）。

運算符	操作	A	N
++	前/後增量	R	1
--	前/後增量	R	1
-	求反	R	1
+	轉換爲數字	R	1
~	按位求反	R	1
!	邏輯非	R	1
delete	刪除屬性	R	1
typeof	檢測類型	R	1
void	返回undefined	R	1
* / %	乘，除，求模	L	2
+ -	加，減	L	2
+	字符串連接	L	2
<<	左移位	L	2
>>	有符號右移	L	2
>>>	無符號右移	L	2
< <= > >=	比較數字順序	L	2
< <= > >=	比較字母順序	L	2
instanceof	測試對象類	L	2
in	測試屬性是否存在	L	2
==	判斷相等	L	2
!=	判斷不等	L	2
===	判斷恆等	L	2
!==	判斷恆不等	L	2
&	按位與	L	2
^	按位異或	L	2
┃	按位或	L	2
&&	邏輯與	L	2
┃┃	邏輯或	L	2
?:	條件運算符	R	3
=	賦值	R	2
*= /= %= += -= &= <<= >>= ^= ┃= >>>=	運算且賦值	R	2
,	忽略第一個操作數， 返回第二個操作數	L	2

因爲 | 是製表符，會導致格式混亂，所以表格中的 | 均以 ┃ 代替。

一元運算符

delete 運算符

delete 運算符用來刪除對象屬性或者數組元素，如果刪除成功或所刪除的目標不存在，delete 將返回 true。然而，並不是所有的屬性都可刪除，一些內置核心和客戶端屬性是不能刪除的，通過 var 語句聲明的變量不能刪除，通過 function 語句定義的函數也是不能刪除的。例如：

var o = { x: 1, y: 2};          // 定義一個對象
console.log(delete o.x);        // true，刪除一個屬性
console.log(delete o.x);        // true，什麼都沒做，x 在已上一步被刪除
console.log("x" in o);          // false，這個屬性在對象中不再存在
console.log(delete o.toString); // true，什麼也沒做，toString是繼承來的
console.log(delete 1);          // true，無意義

var a = [1,2,3];                // 定義一個數組
console.log(delete a[2]);       // true，刪除最後一個數組元素
console.log(2 in a);            // false，元素2在數組中不再存在
console.log(a.length);          // 3，數組長度並不會因 delete 而改變
console.log(a[2]);              // undefined，元素2所在的位置被空了出來
console.log(delete a);          // false，通過 var 語句聲明的變量不能刪除

function f(args){}              // 定義一個函數
console.log(delete f);          // false，通過 function 語句聲明的函數不能刪除

void 運算符

void 運算符可以應用於任何表類型的表達式，表達式會被執行，但計算結果會被忽略並返回 undefined。例如：

void 0;
void "you are useless?";
void false;
void [];
void /(useless)/ig;
void function(){ console.log("you are so useless?"); }
// always return undefined

擴展閱讀「談談 JavaScript 中的 void 運算符」
https://segmentfault.com/a/1190000000474941

typeof 運算符

請參見「變量和數據類型」-「數據類型」-「typeof 運算符」。

++ -- 運算符

++ -- 遞增遞減運算符借鑑自 C 語言，它們分前置型和後置型，作用是改變一個變量的值。例如：

var a = 5;
console.log(a++);   // 5
console.log(++a);   // 7
console.log(a--);   // 7
console.log(--a);   // 5

+ - 運算符

當 + - 作爲一元運算符時，應用於數值，表示數值的正負。應用於非數值，先按 Number() 轉型函數對這個值執行轉換，再表示該值的正負。

~ ! 運算符

~ 按位非運算符，請參見下面「位運算符」。
! 邏輯非運算符，請參見下面「邏輯運算符」。

乘性運算符

JavaScript 定義了3個乘性運算符：乘法、除法和求模。這些運算符與 C 語言的相應運算符用途類似，只不過在操作數爲非數值的情況下會執行自動的類型轉換。如果參與乘法計算的某個操作數不是數值，後臺會先使用 Number() 轉型函數將其轉換爲數值。也就是說，空字符串將被當作 0，布爾值 true 將被當作 1。

* 乘法運算符

用於計算兩個數值的乘積，在處理特殊值的情況下，乘法運算符遵循下列特殊的規則：

• 如果操作數都是數值，執行常規的乘法計算，即兩個正數或兩個負數相乘的結果還是正數，而如果只有一個操作數有符號，那麼結果就是負數。如果乘積超過了 JavaScript 數值的表示範圍，則返回 Infinity 或 -Infinity；
• 如果有一個操作數是 NaN，則結果是 NaN；
• 如果是 Infinity 與 0 相乘，則結果是 NaN；
• 如果是 Infinity 與非 0 數值相乘，則結果是 Infinity 或 -Infinity，取決於有符號操作數的符號；
• 如果是 Infinity 與 Infinity 相乘，則結果是 Infinity；
  如果有一個操作數不是數值，則在後臺調用 Number()將其轉換爲數值，然後再應用上面的規則。

/ 除法運算符

用於計算兩個數值的商，與乘法運算符類似，除法運算符對特殊的值也有特殊的處理規則。這些規則如下：

• 如果操作數都是數值，執行常規的除法計算，即兩個正數或兩個負數相除的結果還是正數，而如果只有一個操作數有符號，那麼結果就是負數。如果商超過了 JavaScript 數值的表示範圍，則返回 Infinity 或 -Infinity；
• 如果有一個操作數是 NaN，則結果是 NaN；
• 如果是 Infinity 被 Infinity 除，則結果是 NaN；
• 如果是零被零除，則結果是 NaN；
• 如果是非零的有限數被零除，則結果是 Infinity 或 -Infinity，取決於有符號操作數的符號；
• 如果是 Infinity 被任何非零數值除，則結果是 Infinity 或 -Infinity，取決於有符號操作數的符號；
• 如果有一個操作數不是數值，則在後臺調用 Number() 將其轉換爲數值，然後再應用上面的規則。

% 求模運算符

用於計算兩個數值的餘數，與另外兩個乘性運算符類似，求模運算符會遵循下列特殊規則來處理特殊的值：

• 如果操作數都是數值，執行常規的除法計算，返回除得的餘數；
• 如果被除數是無窮大值而除數是有限大的數值，則結果是 NaN；
• 如果被除數是有限大的數值而除數是零，則結果是 NaN；
• 如果是 Infinity 被 Infinity 除，則結果是 NaN；
• 如果被除數是有限大的數值而除數是無窮大的數值，則結果是被除數；
• 如果被除數是零，則結果是零；
• 如果有一個操作數不是數值，則在後臺調用 Number() 將其轉換爲數值，然後再應用上面的規則。

加性運算符

加法和減法這兩個加性運算符應該說是編程語言中最簡單的算術運算符了。但是在 JavaScript 中，這兩個運算符卻都有一系列的特殊行爲。與乘性運算符類似，加性運算符也會在後臺轉換不同的數據類型。然而，對於加性運算符而言，相應的轉換規則還稍微有點複雜。

+ 加法運算符

如果兩個運算符都是數值，執行常規的加法計算，然後根據下列規則返回結果：

• 如果有一個操作數是 NaN，則結果是 NaN；
• 如果是 Infinity 加 Infinity，則結果是 Infinity；
• 如果是 -Infinity 加 -Infinity，則結果是 -Infinity；
• 如果是 Infinity 加- Infinity，則結果是 NaN；
• 如果是 +0 加 +0，則結果是 +0；
• 如果是 -0 加 -0，則結果是 -0；
• 如果是 +0 加 -0，則結果是 +0;

如果有一個操作數不是數值，那麼就要應用如下規則：

• 如果兩個操作數都是字符串，則將第二個操作數與第一個操作數拼接起來；
• 如果只有一個操作數是字符串，則將另一個操作數轉換爲字符串，然後再將兩個字符串拼接起來。
• 如果有一個操作數是對象、數值或布爾值，則調用它們的 toString() 方法取得相應的字符串值，然後再應用前面關於字符串的規則。對於 undefined 和 null，則分別調用 String() 函數並取得字符串 "undefined" 和 "null"。
• 如果是 null 加 null，則結果是 0;
• 如果是 undefined 加 undefined，則結果是 NaN;

下面來舉幾個例子：

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;
console.log(message);   // "The sum of 5 and 10 is 510"，如何修改？

- 減法運算符

如果兩個運算符都是數值，執行常規的減法計算，然後根據下列規則返回結果：

• 如果有一個操作數是 NaN，則結果是 NaN；
• 如果是 Infinity 減 Infinity，則結果是 NaN；
• 如果是 -Infinity 減 -Infinity，則結果是 NaN；
• 如果是 Infinity 減 -Infinity，則結果是 Infinity；
• 如果是 -Infinity 減 Infinity，則結果是 -Infinity；
• 如果是 +0 減 +0，則結果是 +0；
• 如果是 +0 減 -0，則結果是 -0；
• 如果是 -0 減 -0，則結果是 +0；

如果有一個操作數不是數值，那麼就要應用如下規則：

• 如果有一個操作數是字符串、布爾值、null 或 undefined，則先在後臺調用 Number() 函數將其轉換爲數值，然後再根據前面的規則執行減法計算。如果轉換的結果是 NaN，則減法的結果就是 NaN；
• 如果有一個操作數是對象，則調用對象的 valueOf() 方法以取得表示該對象的數值。如果得到的值是 NaN，則減法的結果就是 NaN。如果對象沒有 valueOf() 方法，則調用其 toString()方法並將得到的字符串轉換爲數值。
• 如果是 null 減 null，則結果是 0;
• 如果是 undefined 減 undefined，則結果是 NaN;

下面來舉幾個例子：

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 中的相等和不等運算符會在執行比較之前，先將對象轉換成相似的類型。後來，有人提出了這種轉換到底是否合理的質疑。最後，JavaScript 的解決方案就是提供兩組運算符：相等和不相等（先轉換再比較），恆等和不恆等（僅比較而不轉換）。

== != 運算符

== != 這兩個運算符都會先轉換操作數（通常稱爲強制轉型），然後再比較它們的相等性。在轉換不同的數據類型時，相等和不相等運算符遵循下列基本規則：

• 如果有一個操作數是布爾值，則在比較相等性之前先將其轉換爲數值（false 轉換爲 0，而 true 轉換爲 1）；
• 如果一個操作數是字符串，另一個操作數是數值，在比較相等性之前先將字符串轉換爲數值；
• 如果一個操作數是對象，另一個操作數不是，則調用對象的 valueOf() 方法，用得到的基本類型值按照前面的規則進行比較；
• null 和 undefined 是相等的。
  要比較相等性之前，不能將 null 和 undefined 轉換成其他任何值。
• 如果有一個操作數是 NaN，則相等運算符返回 false，而不相等運算符返回 true。重要提示：即使兩個操作數都是 NaN，相等運算符也返回 false；因爲按照規則，NaN 不等於 NaN。
• 如果兩個操作數都是對象，則比較它們是不是同一個對象。如果兩個操作數都指向同一個對象，則相等運算符返回 true；否則，返回 false。

列出了一些特殊情況及比較結果：

null == undefined   // true
"NaN" == NaN        // false
5 == NaN            // false
NaN == NaN          // false
NaN != NaN          // true
false == 0          // true
true == 1           // true
true == 2           // false
undefined == 0      // false
null == 0           // false
"5" == 5            // true

=== !== 運算符

除了在比較之前不轉換操作數之外，恆等和不恆等運算符與相等和不相等運算符沒有什麼區別。它只在兩個操作數未經轉換就相等的情況下返回 true，如下面的例子所示：

var result1 = ("55" == 55);     // true，因爲轉換後相等
var result2 = ("55" === 55);    // false，因爲不同的數據類型不相等
var result3 = (null == undefined)   // true，因爲它們是類似的值
var result4 = (null === undefined)  // false，因爲它們是不同類型的值

關係運算符

< > <= >= 運算符

< 小於、> 大於、<= 小於等於、 >= 大於等於 這幾個關係運算符用於對兩個值進行比較返回一個布爾值。與 JavaScript 中的其他運算符一樣，當關系運算符的操作數使用了非數值時，也要進行數據轉換或完成某些奇怪的操作。以下就是相應的規則。

• 如果兩個操作數都是數值，則執行數值比較。
• 如果兩個操作數都是字符串，則比較兩個字符串對應的字符編碼值（可以通過字符串的 charCodeAt() 函數獲取字符編碼值）。
• 如果一個操作數是數值，則將另一個操作數轉換爲一個數值，然後執行數值比較。
• 如果一個操作數是對象，則調用這個對象的 valueOf() 方法，用得到的結果按照前面的規則執行比較。如果對象沒有 valueOf()方法，則調用 toString()方法，並用得到的結果根據前面的規則執行比較。
• 如果一個操作數是布爾值，則先將其轉換爲數值，然後再執行比較。

請思考下面幾個例子的結果是如何得出的：

var result1 = "Brick" < "alphabet";     // true
var result2 = "brick" < "alphabet";     // false
var result3 = "23" < "3";   // true
var result4 = "23" < 3;     // false
var result5 = "a" < 3;      // false
var result6 = NaN < 3;      // false
var result7 = NaN >= 3;     // false

in 運算符

in 運算符希望它的左操作數是一個字符串或可以轉換爲字符串，希望它的右操作數是一個對象。如果右側的對象擁有一個名爲左操作數值的屬性名，那麼表達式返回 true，例如：

var point = { x:1, y:1 };       // 定義一個對象
"x" in point                    // true，對象有一個名爲"x"的屬性
"z" in point                    // false，對象中不存在名爲"z"的屬性
"toString" in point             // true，對象繼承了toString()方法

var data = [7,8,9];             // 擁有三個元素的數組
"0" in data                     // true，數組包含元素"0"
1 in data                       // true，數字轉換爲字符串
3 in data                       // false，沒有索引爲3的元素

instanceof 運算符

instanceof 運算符希望左操作數是一個對象，右操作數標識對象的類。如果左側的對象是右側類的實例，則表達式返回 true；否則返回 false。後面會講 JavaScript 中對象的類是通過初始化它們的構造函數來定義的。這樣的話，instanceof 的右操作數應當是一個函數。比如：

var d = new Date();     // 通過 Date() 構造函數來創建一個新對象
d instanceof Date;      // true，d 是由 Date() 創建的
d instanceof Object;    // true，所有的對象都是 Object 的實例
d instanceof Number;    // false，d 不是一個 Number 對象

var a = [1, 2, 3];      // 通過數組字面量的寫法創建一個數組
a instanceof Array;     // true，a 是一個數組
a instanceof Object;    // true，所有的數組都是對象
a instanceof RegExp;    // false，數組不是正則表達式

需要注意的是，所有的對象都是 Object 的實例。當通過 instanceof 判斷一個對象是否是一個類的實例的時候，這個判斷也會包含對「父類」的檢測。如果 instanceof 的左操作數不是對象的話，instanceof 返回 false。如果右操作數不是函數，則拋出一個類型錯誤異常。

邏輯運算符

邏輯運算符是對操作數進行布爾算術運算，經常和關係運算符一起配合使用，邏輯運算符將多個關係表達式組合起來組成一個更復雜的表達式。

&& 邏輯與

邏輯與操作可以應用於任何類型的操作數，而不僅僅是布爾值。在有一個操作數不是布爾值的情況下，邏輯與操作不一定返回布爾值；此時，它遵循下列規則：

• 如果第一個操作數是對象，則返回第二個操作數；
• 如果第二個操作數是對象，則只有在第一個操作數的求值結果爲 true 的情況下才會返回該對象；
• 如果兩個操作數都是對象，則返回第二個操作數；
• 如果有一個操作數是 null，則返回 null；
• 如果有一個操作數是 NaN，則返回 NaN；
• 如果有一個操作數是 undefined，則返回 undefined。

邏輯與操作屬於短路操作，即如果第一個操作數能夠決定結果，那麼就不會再對第二個操作數求值。對於邏輯與操作而言，如果第一個操作數是 false，無論第二個操作數是什麼值，結果都不再可能是 true 了。

|| 邏輯或

與邏輯與操作相似，如果有一個操作數不是布爾值，邏輯或也不一定返回布爾值；此時，它遵循下列規則：

• 如果第一個操作數是對象，則返回第一個操作數；
• 如果第一個操作數的求值結果爲 false，則返回第二個操作數；
• 如果兩個操作數都是對象，則返回第一個操作數；
• 如果兩個操作數都是 null，則返回 null；
• 如果兩個操作數都是 NaN，則返回 NaN；
• 如果兩個操作數都是 undefined，則返回 undefined。

與邏輯與運算符相似，邏輯或運算符也是短路運算符。也就是說，如果第一個操作數的求值結果爲 true，就不會對第二個操作數求值了。

! 邏輯非

邏輯非操作可以應用於任何類型的操作數，無論這個值是什麼數據類型，這個運算符都會返回一個布爾值。邏輯非運算符首先會將它的操作數轉換爲一個布爾值，然後再對其求反。邏輯非運算符遵循下列規則：

• 如果操作數是一個對象，返回 false；
• 如果操作數是一個空字符串，返回 true；
• 如果操作數是一個非空字符串，返回 false；
• 如果操作數是數值 0，返回 true；
• 如果操作數是任意非 0 數值（包括 Infinity），返回 false；
• 如果操作數是 null，返回 true；
• 如果操作數是 NaN，返回 true；
• 如果操作數是 undefined，返回 true。

下面幾個例子展示了應用上述規則的結果：

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() 函數相同，例如：

console.log(!!"blue");        //true
console.log(!!0);             //false
console.log(!!NaN);           //false
console.log(!!"");            //false
console.log(!!12345);         //true

位運算符

在 JavaScript 中，當對數值應用位運算符時，後臺會發生如下轉換過程：64位的數值被轉換成32位數值，然後執行位操作，最後再將32位的結果轉換回64位數值。這個轉換過程導致了一個嚴重的副效應，即在對特殊的 NaN 和 Infinity 值應用位操作時，這兩個值都會被當成 0 來處理。如果對非數值應用位運算符，會先使用 Number() 函數將該值轉換爲一個數值，然後再應用位操作，得到的結果將是一個數值。

~ 按位非

簡單的理解，對任一數值 x 進行按位非操作的結果爲 -(x+1)。例如：

console.log(~null);         // -1
console.log(~undefined);    // -1
console.log(~0);            // -1
console.log(~{});           // -1
console.log(~[]);           // -1
console.log(~(1/0));        // -1
console.log(~false);        // -1
console.log(~true);         // -2
console.log(~1.2543);       // -2
console.log(~4.9);          // -5
console.log(~(-2.999));     // 1

& 按位與

按位與操作就是將兩個數值的每一位對齊，兩個數值的對應位都是 1 時才返回 1，任何一位是 0，結果都是 0。如下表所示：

第一個數值的位	第二個數值的位	結果
1	1	1
1	0	0
0	1	0
0	0	0

| 按位或

按位或操作就是將兩個數值的每一位對齊，兩個數值只要有一個位是 1 就返回 1，只在兩個位都是 0 的情況下才返回 0。如下表所示：

第一個數值的位	第二個數值的位	結果
1	1	1
1	0	1
0	1	1
0	0	0

^ 按位異或

按位異或與按位或的不同之處在於，兩個數值只有一個 1 時才返回 1，如果對應的兩位都是 1 或都是 0，則返回 0。

第一個數值的位	第二個數值的位	結果
1	1	0
1	0	1
0	1	1
0	0	0

<< 左移

這個運算符會將數值的所有位向左移動指定的位數。例如：

var oldValue = 2;                       // 等於二進制的 10
var newValue = oldValue << 5;           // 等於二進制的 1000000，十進制的 64

注意，左移不會影響操作數的符號位。換句話說，如果將 -2 向左移動 5 位，結果將是 -64，而非 64。

>> 有符號的右移

這個運算符會將數值向右移動，但保留符號位（即正負號標記）。

var oldValue = 64;                      // 等於二進制的 1000000
var newValue = oldValue >> 5;           // 等於二進制的 10 ，即十進制的 2

>>> 無符號的右移

這個運算符會將數值的所有32位都向右移動。對正數來說，無符號右移的結果與有符號右移相同。

var oldValue = 64;                      // 等於二進制的 1000000
var newValue = oldValue >>> 5;          // 等於二進制的 10 ，即十進制的 2

無符號右移運算符會把負數的二進制碼當成正數的二進制碼。而且，由於負數以其絕對值的二進制補碼形式表示，因此就會導致無符號右移後的結果非常之大。

var oldValue = -64;                     // 等於二進制的 11111111111111111111111111000000
var newValue = oldValue >>> 5;          // 等於十進制的 134217726

賦值運算符

簡單的賦值運算符由等於號 = 表示，其作用就是把右側的值賦給左側的變量，如下面的例子所示：

var num = 10;

如果在等於號 = 前面再添加乘性運算符、加性運算符或位運算符，就可以完成複合賦值操作。這種複合賦值操作相當於是對下面常規表達式的簡寫形式：

var num = 10;
num += 10;      // 等同於 num = num + 10;

每個主要算術運算符（以及個別的其他運算符）都有對應的複合賦值運算符。這些運算符如下所示：

• 乘/賦值 *=；
• 除/賦值 /=；
• 模/賦值 %=；
• 加/賦值 +=；
• 減/賦值 -=；
• 左移/賦值 <<=；
• 有符號右移/賦值 >>=；
• 無符號右移/賦值 >>>=。

設計這些運算符的主要目的就是簡化賦值操作，使用它們不會帶來任何性能的提升。

條件運算符

? : 條件運算符應該算是 JavaScript 中最靈活的一種運算符了，而且它遵循與 Java 中的條件運算符相同的語法形式，如下面的例子所示：

variable = boolean_expression ? true_value : false_value;

逗號運算符

逗號運算符多用於聲明多個變量；但除此之外，逗號運算符還可以用於賦值。在用於賦值時，逗號運算符總會返回表達式中的最後一項，如下面的例子所示：

var num = (5, 1, 4, 8, 0); // num 的值爲 0

由於 0 是表達式中的最後一項，因此 num 的值就是 0。雖然逗號的這種使用方式並不常見，但這個例子可以幫我們理解逗號的這種行爲。

關卡

// 挑戰一
var x=1;
if(!!function f(){}){
    x+=typeof f;
}
console.log(x);     // ???

// 挑戰二
(function f(f){
    console.log(typeof f());    // ???
})(function(){return 1;});

// 挑戰三
console.log(typeof 2*3);    // ???
console.log(typeof 2+3);    // ???

// 挑戰四
var a=0,b=0;
console.log(a+++b);     // ???
console.log(a);         // ???
console.log(b);         // ???

// 挑戰五
var a,b,c;
a=b==c;
console.log(a);     // ???

// 挑戰六
console.log(1 && 3);            // ???
console.log(1 && "foo" || 0);   // ???
console.log(1 || "foo" && 0);   // ???

// 挑戰七
var a=1;
var b=(a=(2,4,6))+a++
console.log(b);     // ???

// 挑戰八
if (!("a" in window)) {
    var a = 1;
}
console.log(a);     // ???

// 挑戰九
var val = 'smtg'; 
console.log('Value is ' + (val === 'smtg') ? 'Something' : 'Nothing');  // ???

// 挑戰九
console.log(1 + - + + + - + 1);

更多

關注微信公衆號「劼哥舍」回覆「答案」，獲取關卡詳解。
關注 https://github.com/stone0090/javascript-lessons，獲取最新動態。