摘要：上半部選擇題解答個人博客文章地址第二十一題又是一道考查數字的題，與第七題考察點相似。

上半部：JavaScript選擇題解答（1-20）

個人博客文章地址

What is the result of this expression? (or multiple ones)

var a = 111111111111111110000,
    b = 1111;
a + b;

A: 111111111111111111111

B: 111111111111111110000

C: NaN

D: Infinity

又是一道考查JavaScript數字的題，與第七題考察點相似。由于JavaScript實際上只有一種數字形式IEEE 754標準的64位雙精度浮點數，其所能表示的整數范圍為-2^53~2^53(包括邊界值)。這里的111111111111111110000已經超過了2^53次方，所以會發生精度丟失的情況。綜上選B

What is the result of this expression? (or multiple ones)

var x = [].reverse;
x();

A: []

B: undefined

C: error

D: window

這題考查的是函數調用時的this和Array.prototype.reverse方法。

首先看Array.prototype.reverse方法，首先舉幾個栗子：

console.log(Array.prototype.reverse.call("skyinlayer"));
//skyinlayer
console.log(Array.prototype.reverse.call({}));
//Object {}
console.log(Array.prototype.reverse.call(123));
//123

這幾個栗子可以得出一個結論，Array.prototype.reverse方法的返回值，就是this

Javascript中this有如下幾種情況：

全局下this，指向window對象

console.log(this);
//輸出結果：
//Window {top: Window, window: Window, location: Location, external: Object, chrome: Object…}

函數調用，this指向全局window對象：

function somefun(){
    console.log(this);
}
somefun();
//輸出結果：
//Window {top: Window, window: Window, location: Location, external: Object, chrome: Object…}

方法調用，this指向擁有該方法的對象：

var someobj = {};
someobj.fun = function(){
    console.log(this);
};
console.log(someobj.fun());
//輸出結果：
//Object {fun: function}

調用構造函數，構造函數內部的this指向新創建對象：

function Con() {
    console.log(this);
}
Con.prototype.somefun = function(){};
console.log(new Con());
//輸出結果：
//Con {somefun: function}

顯示確定this：

function somefun(){
    console.log(this);
};
somefun.apply("skyinlayer");
somefun.call("skyinlayer");
//輸出結果：
//String {0: "s", 1: "k", 2: "y", 3: "i", 4: "n", 5: "l", 6: "a", 7: "y", 8: "e", 9: "r", length: 10}
//String {0: "s", 1: "k", 2: "y", 3: "i", 4: "n", 5: "l", 6: "a", 7: "y", 8: "e", 9: "r", length: 10} 

這里可以看到，使用的是函數調用方式，this指向的是全局對象window，所以選D

What is the result of this expression? (or multiple ones)

Number.MIN_VALUE > 0

A: false

B: true

C: error

D: other

考查的Number.MIN_VALUE的概念，MDN傳送門，關鍵的幾句話
* The Number.MIN_VALUE property represents the smallest positive numeric value representable in JavaScript.
翻譯：Number.MIN_VALUE表示的是JavaScript中最小的正數

The MIN_VALUE property is the number closest to 0, not the most negative number, that JavaScript can represent.
翻譯：MIN_VALUE是接近0的數，而不是最小的數

MIN_VALUE has a value of approximately 5e-324. Values smaller than MIN_VALUE ("underflow values") are converted to 0.
翻譯：MIN_VALUE值約等于5e-324，比起更小的值（大于0），將被轉換為0

所以，這里是true，選B

順帶把Number的幾個常量拉出來：
* Number.MAX_VALUE：最大的正數
* Number.MIN_VALUE：最小的正數
* Number.NaN：特殊值，用來表示這不是一個數
* Number.NEGATIVE_INFINITY：負無窮大
* Number.POSITIVE_INFINITY：正無窮大

如果要表示最小的負數和最大的負數，可以使用-Number.MAX_VALUE和-Number.MIN_VALUE

What is the result of this expression? (or multiple ones)

[1 < 2 < 3, 3 < 2 < 1]

A: [true, true]

B: [true, false]

C: error

D: other

運算符的運算順序和隱式類型轉換的題，從MDN上運算符優先級，"<"運算符順序是從左到右，所以變成了[true < 3, false < 1]

接著進行隱式類型轉換，"<"操作符的轉換規則（來自$雨$的文章《Javascript類型轉換的規則》）:

如果兩個操作值都是數值，則進行數值比較

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

如果只有一個操作值是數值，則將另一個操作值轉換為數值，進行數值比較

如果一個操作數是對象，則調用valueOf()方法（如果對象沒有valueOf()方法則調用toString()方法），得到的結果按照前面的規則執行比較

如果一個操作值是布爾值，則將其轉換為數值，再進行比較

所以，這里首先通過Number()轉換為數字然后進行比較，true會轉換成1，而false轉換成0，就變成了[1 < 3, 0 < 1]

所以結果為A

What is the result of this expression? (or multiple ones)

// the most classic wtf
2 == [[[2]]]

A: true

B: false

C: undefined

D: other

又是隱式類型轉換的題（汗）

題目作者的解釋是：
both objects get converted to strings and in both cases the resulting string is "2"

也就是說左右兩邊都被轉換成了字符串，而字符串都是"2"

這里首先需要對==右邊的數組進行類型轉換，根據以下規則（來自justjavac的文章《「譯」JavaScript 的怪癖 1：隱式類型轉換》）：
1. 調用 valueOf()。如果結果是原始值（不是一個對象），則將其轉換為一個數字。
2. 否則，調用 toString() 方法。如果結果是原始值，則將其轉換為一個數字。
3. 否則，拋出一個類型錯誤。

所以右側被使用toString()方法轉換為"2"，然后又通過Number("2")轉換為數字2進行比較，結果就是true了，選A

What is the result of this expression? (or multiple ones)

3.toString()
3..toString()
3...toString()

A: "3", error, error

B: "3", "3.0", error

C: error, "3", error

D: other

說實話這題有點常見了，很多人都踩過3.toString()的坑（包括我）...雖然JavaScript會在調用方法時對原始值進行包裝，但是這個點是小數點呢、還是方法調用的點呢，于是乎第一個就是error了，因為JavaScript解釋器會將其認為是小數點。

而第二個則很好說通了，第一個點解釋為小數點，變成了(3.0).toString()，結果就是"3"了

第三個也是，第一個點為小數點，第二個是方法調用的點，但是后面接的不是一個合法的方法名，于是乎就error了

綜上，選C

What is the result of this expression? (or multiple ones)

(function(){
  var x = y = 1;
})();
console.log(y);
console.log(x);

A: 1, 1

B: error, error

C: 1, error

D: other

變量提升和隱式定義全局變量的題，也是一個JavaScript經典的坑...

還是那句話，在作用域內，變量定義和函數定義會先行提升，所以里面就變成了:

(function(){
    var x;
    y = 1;
    x = 1;
})();

這點會問了，為什么不是var x, y;，這就是坑的地方...這里只會定義第一個變量x，而y則會通過不使用var的方式直接使用，于是乎就隱式定義了一個全局變量y

所以，y是全局作用域下，而x則是在函數內部，結果就為1, error，選C

What is the result of this expression? (or multiple ones)

var a = /123/,
    b = /123/;
a == b
a === b

A: true, true

B: true, false

C: false, false

D: other

首先需要明確JavaScript的正則表達式是什么。JavaScript中的正則表達式依舊是對象，使用typeof運算符就能得出結果：

console.log(typeof /123/);
//輸出結果：
//"object"

==運算符左右兩邊都是對象時，會比較他們是否指向同一個對象，可以理解為C語言中兩個指針的值是否一樣（指向同一片內存），所以兩個結果自然都是false

What is the result of this expression? (or multiple ones)

var a = [1, 2, 3],
    b = [1, 2, 3],
    c = [1, 2, 4]
a == b
a === b
a > c
a < c

A: false, false, false, true

B: false, false, false, false

C: true, true, false, true

D: other

和上題類似，JavaScript中Array的本質也是對象，所以前兩個的結果都是false，

而JavaScript中Array的">"運算符和"<"運算符的比較方式類似于字符串比較字典序，會從第一個元素開始進行比較，如果一樣比較第二個，還一樣就比較第三個，如此類推，所以第三個結果為false，第四個為true。

綜上所述，結果為false, false, false, true，選A

What is the result of this expression? (or multiple ones)

var a = {}, b = Object.prototype;
[a.prototype === b, Object.getPrototypeOf(a) === b]

A: [false, true]

B: [true, true]

C: [false, false]

D: other

原型鏈的題（總會有的），考查的__proto__和prototype的區別。首先要明確對象和構造函數的關系，對象在創建的時候，其__proto__會指向其構造函數的prototype屬性

Object實際上是一個構造函數（typeof Object的結果為"function"）,使用字面量創建對象和new Object創建對象是一樣的，所以a.__proto__也就是Object.prototype，而Object.getPrototypeOf(a)與a.__proto__是一樣的，所以第二個結果為true

而實例對象是沒有prototype屬性的，只有函數才有，所以a.prototype其實是undefined，第一個結果為false

綜上，選A

What is the result of this expression? (or multiple ones)

function f() {}
var a = f.prototype, b = Object.getPrototypeOf(f);
a === b

A: true

B: false

C: null

D: other

還是__proto__和prototype的區別，兩者不是一個東西，所以選B

What is the result of this expression? (or multiple ones)

function foo() { }
var oldName = foo.name;
foo.name = "bar";
[oldName, foo.name]

A: error

B: ["", ""]

C: ["foo", "foo"]

D: ["foo", "bar"]

考察了函數的name屬性，使用函數定義方式時，會給function對象本身添加一個name屬性，保存了函數的名稱，很好理解oldName為"foo"。name屬性時只讀的，不允許修改，所以foo.name = "bar";之后，foo.name還是"foo"，所以結果為["foo", "foo"]，選C

PS：name屬性不是一個標準屬性，不要去使用，除非你想要坑別人

What is the result of this expression? (or multiple ones)

"1 2 3".replace(/d/g, parseInt)

A: "1 2 3"

B: "0 1 2"

C: "NaN 2 3"

D: "1 NaN 3"

String.prototype.replace、正則表達式的全局匹配和parseInt（又是parseInt...），可以根據題意看出來題目上漏了一個""

首先需要確定replace會傳給parseInt哪些參數。舉個栗子：

"1 2 3".replace(/d/g, function(){
    console.log(arguments);
});
//輸出結果：
//["1", 0, "1 2 3"]
//["2", 2, "1 2 3"]
//["3", 4, "1 2 3"] 

一共三個：
1. match：正則表達式被匹配到的子字符串
2. offset：被匹配到的子字符串在原字符串中的位置
3. string：原字符串

這樣就很好理解了，又回到之前parseInt的問題了，結果就是parseInt("1", 10), parseInt("2", 2), parseInt("3", 4)所以結果為"1, NaN, 3"，選D

What is the result of this expression? (or multiple ones)

function f() {}
var parent = Object.getPrototypeOf(f);
f.name // ?
parent.name // ?
typeof eval(f.name) // ?
typeof eval(parent.name) //  ?

A: "f", "Empty", "function", "function"

B: "f", undefined, "function", error

C: "f", "Empty", "function", error

D: other

又是Function.name屬性的題，和三十二題一樣樣，f.name值為"f"，而eval("f")則會輸出f函數，所以結果為"function"

接著看parent，parent實際上就是f.__proto__，需要明確的是JavaScript中的函數也是對象，其也有自己的構造函數Function，所以f.__proto__ === Function.prototype結果是true，而Function.prototype就是一個名為Empty的function

console.log(Function.prototype);
console.log(Function.prototype.name);
//輸出結果：
//function Empty() {}
//Empty

所以parent.name的值為Empty

如果想直接在全局作用域下調用Empty，顯示未定義...因為Empty并不在全局作用域下

綜上所述，結果為C

What is the result of this expression? (or multiple ones)

var lowerCaseOnly =  /^[a-z]+$/;
[lowerCaseOnly.test(null), lowerCaseOnly.test()]

A: [true, false]

B: error

C: [true, true]

D: [false, true]

正則表達式的test方法會自動將參數轉換為字符串，原式就變成了[lowerCaseOnly.test("null"), lowerCaseOnly.test("undefined")]，結果都是真，所以選C

What is the result of this expression? (or multiple ones)

[,,,].join(", ")

A: ", , , "

B: "undefined, undefined, undefined, undefined"

C: ", , "

D: ""

JavaScript中使用字面量創建數組時，如果最末尾有一個逗號","，會背省略，所以實際上這個數組只有三個元素（都是undefined）：

console.log([,,,].length);
//輸出結果：
//3

而三個元素，使用join方法，只需要添加兩次，所以結果為", , "，選C

What is the result of this expression? (or multiple ones)

var a = {class: "Animal", name: "Fido"};
a.class

A: "Animal"

B: Object

C: an error

D: other

經典坑中的一個，class是關鍵字。根據瀏覽器的不同，結果不同：

chrome的結果： "Animal"

Firefox的結果："Animal"

Opera的結果："Animal"

IE 8以上也是： "Animal"

IE 8 及以下： 報錯

終于把37題全部弄完了，雖然很多題都偏而怪，但其中涉及的知識還是相當重要的。JavaScript中的糟粕和精華永遠是一個話題，也是筆試面試時經常遇到的問題。