摘要：表示要解析的數字的基數。回調函數接收四個參數，依次是通過上一次調用回調函數獲得的值。如果向方法提供，則在首次調用函數時，為。當前數組元素的值。

原題出處：JavaScript Puzzlers!
當初以為不過是一些小題目，結果做到懷疑人生，都要懷疑可能我javascript白學了。讀者可以去試試。

不多說，直接上題：

["1", "2", "3"].map(parseInt)

不要被套路，這題沒看上去那么簡單，首先我們來看看Array.map這個函數：

array.map(function(currentValue,index,arr), thisValue)

map() 方法按照原始數組元素順序依次處理元素，返回一個新數組，數組中的元素為原始數組元素調用函數處理后的值。

map接收兩個參數，一個回調函數，一個是可選的回調函數的this值，默認為undefined

其中回調函數接收三個參數，依次是當前元素的值，可選的當前元素的索引值和當期元素屬于的數組對象

題目中只傳入了parseInt函數，讓我們再看看parseInt這個函數：

parseInt(string, radix)

parseInt() 函數可解析一個字符串，并返回一個整數。
string: 必需。要被解析的字符串。
radix: 可選。表示要解析的數字的基數。該值介于 2 ~ 36 之間。

當忽略參數 radix , JavaScript 默認數字的基數如下:

如果 string 以 "0x" 開頭，parseInt() 會把 string 的其余部分解析為十六進制的整數。

如果 string 以 0 開頭，那么 ECMAScript v3 允許 parseInt() 的一個實現把其后的字符解析為八進制或十六進制的數字。

如果 string 以 1 ~ 9 的數字開頭，parseInt() 將把它解析為十進制的整數。

把這題分開來看就是：

// parseInt(currenValue, index)
parseInt("1", 0)    // 1
parseInt("2", 1)    // NaN
parseInt("3", 2)    // NaN

答案就是： [1, NaN, NaN]

[typeof null, null instanceof Object]

這題還好一點，typeof 返回一個表示類型的字符串. instanceof 運算符用來檢測 constructor.prototype 是否存在于參數 object 的原型鏈上.

我們都知道在javascript一切皆是對象，所以第一部分不用說，返回的肯定是Object，但是null并不存在于參數 object 的原型鏈上.

所以答案就是： [Object, false]

[ [3,2,1].reduce(Math.pow), [].reduce(Math.pow) ]

先說說Array.reduce這個方法吧：

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

reduce接收兩個參數，一個回調函數，一個可選的將用作累積的初始值。

如果提供了 initialValue，則 reduce 方法會對數組中的每個元素調用一次 callbackfn 函數（按升序索引順序）。如果未提供 initialValue，則 reduce 方法會對從第二個元素開始的每個元素調用 callbackfn 函數。

回調函數接收四個參數，依次是

通過上一次調用回調函數獲得的值。如果向 reduce 方法提供 initialValue，則在首次調用函數時，total 為 initialValue。

當前數組元素的值。

當前數組元素的數字索引。

包含該元素的數組對象。

Math.pow(x,y)

pow() 方法返回 x 的 y 次冪。

[3, 2, 1].reduce(Math.pow) 拆分開來就是：

Math.pow(3, 2)    // 9
Math.pow(9, 1)    // 9

但是reduce在兩個情況下會拋出異常：

當滿足下列任一條件時，將引發 TypeError 異常： callbackfn 參數不是函數對象。

數組不包含元素，且未提供 initialValue。

所以 [].reduce(Math.pow) 會拋出異常

答案為：an error

var val = "smtg";
console.log("Value is " + (val === "smtg") ? "Something" : "Nothing");

這題看上去很簡單對不對？答案不就是 Value is Something，如果你真的這么想，你會哭的，是的，筆者已經親自試毒了。

簡單來說就是+的優先級大于？

所以原題等價于：

console.log("Value is true" ? "Something" : "Nothing")

答案應該是 Something

var name = "World!";
(function () {
    if (typeof name === "undefined") {
        var name = "Jack";
        console.log("Goodbye " + name);
    } else {
        console.log("Hello " + name);
    }
})();

我還是先說答案吧，可能你們會不相信，答案就是 Goodbye, Jack

為什么會這樣呢，因為在javascript里，聲明變量或函數會被提升，就是說，
變量提升是JavaScript將聲明移至作用域 scope (全局域或者當前函數作用域) 頂部的行為。
你可以先使用一個函數或變量，再聲明它：

show("Wiess")    // Hello Wiess
function (name) {
    console.log("Hello " + name)
}

但是javascript只提升聲明，而不是初始化，如果使用一個在已經使用后才聲明和初始化的值，這個值將是undefined

所以這題就相當于：

var name = "World!";
(function () {
    var name;
    if (typeof name === "undefined") {
        name = "Jack";
        console.log("Goodbye " + name);
    } else {
        console.log("Hello " + name);
    }
})();

到這里是不是有點肝疼？習慣就好，習慣就好

var END = Math.pow(2, 53);
var START = END - 100;
var count = 0;
for (var i = START; i <= END; i++) {
    count++;
}
console.log(count);

Math.pow(2, 53) = 9007199254740992(可以表示的最大值) 最大值加1還是9007199254740992，所以這個循環會一直下去

答案是： other

var ary = [0,1,2];
ary[10] = 10;
ary.filter(function(x) { return x === undefined;});

這里先科普一下Array.filter():

var newArray = array.filter(function(currentValue,index,arr), thisValue)

filter() 方法創建一個新的數組，新數組中的元素是通過檢查指定數組中符合條件的所有元素。

filter接收兩個參數， 一個回調函數，一個是可選的回調函數的this值，默認為undefined

回調函數依次接收三個參數：

必須。當前元素的值

可選。當期元素的索引值

可選。當期元素屬于的數組對象

再說稀疏矩陣，當你取數組中某個沒有定義的數時：

arr[4]    // undefined

但是當你遍歷它時,你會發現,它并沒有元素。
JavaScript會跳過這些縫隙.

所以答案為： []

var two   = 0.2
var one   = 0.1
var eight = 0.8
var six   = 0.6
[two - one == one, eight - six == two]

這題筆者認為應該選[false, false]，但是答案卻是[true, false]

就不說javascript里沒有精確的浮點數了，這個大家應該都知道，但是為什么不能一視同仁呢？！希望有個大神來解答一下

function showCase(value) {
    switch(value) {
    case "A":
        console.log("Case A");
        break;
    case "B":
        console.log("Case B");
        break;
    case undefined:
        console.log("undefined");
        break;
    default:
        console.log("Do not know!");
    }
}
showCase(new String("A"));

這題主要考察的是switch，在switch里，比較用的是 ===，所以new String("A") 與 字面聲明的 "A"是不一樣的，所以答案是 Do not know!

function showCase2(value) {
    switch(value) {
    case "A":
        console.log("Case A");
        break;
    case "B":
        console.log("Case B");
        break;
    case undefined:
        console.log("undefined");
        break;
    default:
        console.log("Do not know!");
    }
}
showCase2(String("A"));

String（x）不創建對象，但返回一個字符串，即typeof String（1）===“string”

所以答案為 Case A