摘要：表示要解析的數(shù)字的基數(shù)。得到的是，但是注意與所有值都不相等包括本身。所以結(jié)果為第題解析屬性表示在中所能表示的最小的正值。屬性是里最接近的正值，而不是最小的負(fù)值。

原文題目來自：http://javascript-puzzlers.he...
參考的解答：http://www.admin10000.com/doc...

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

解析：.map(callback(value, index, array))回調(diào)函數(shù)傳入三個(gè)參數(shù)，parseInt(string, radix)接收兩個(gè)參數(shù)。所以map傳遞給parseInt的參數(shù)是這樣的（parseInt忽略map傳遞的第三個(gè)參數(shù)）[1, 0],[2, 1],[3, 2]，然乎parseInt()解析傳過來的參數(shù)。

相當(dāng)于執(zhí)行以下語句：

parseInt("1", 0); 當(dāng)radix為0時(shí)，默認(rèn)為10進(jìn)制，所以返回1
parseInt("2", 1); 沒有1進(jìn)制，所以返回NaN
parseInt("3", 2); 二進(jìn)制中只有數(shù)字1、2，沒有數(shù)字3，所以返回NaN

parseInt(string, radix) radix可選。表示要解析的數(shù)字的基數(shù)。該值介于 2 ~ 36 之間。如果省略該參數(shù)或其值為 0，則數(shù)字將以 10 為基礎(chǔ)來解析。如果它以 “0x” 或 “0X” 開頭，將以 16 為基數(shù)。如果該參數(shù)小于 2 或者大于 36，則 parseInt() 將返回 NaN

所以結(jié)果為 [1, NaN, NaN]

[typeof null, null instanceof Object];

解析：typeof 返回一個(gè)表示類型的字符串，總是返回一個(gè)字符串。instanceof 運(yùn)算符用來測試一個(gè)對象在其原型鏈中是否存在一個(gè)構(gòu)造函數(shù)的 prototype 屬性，總是返回布爾值。

typeof null === "object" 
typeof undefined === "undefined"
typeof Infinity === "number"
typeof NaN === "number"

function c () {}
function d () {}

let o = new c();

o instanceof c; //true,因?yàn)镺bject.getPrototypeOf(o) === c.prototype)
o instanceof Object; //true;因?yàn)镺bject.prototype.isPrototypeOf(o)返回true

所以結(jié)果為 [object, false]

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

解析：arr.reduce(callback, [initialValue])

callback包含四個(gè)參數(shù)

accumulator上一次調(diào)用回調(diào)返回的值，或者是提供的初始值（initialValue）

currentValue 數(shù)組中正在處理的元素

currentIndex 數(shù)組中正在處理的的元素索引

array 調(diào)用reduce的數(shù)組

initialValue 其值用于第一次調(diào)用callback的第一個(gè)參數(shù)

另外如果數(shù)組為空并且沒有提供initialValue，會拋出TypeError

第一個(gè)表達(dá)式等價(jià)于Math.pow(3, 2) => 9, Math.pow(9, 1) => 9

所以結(jié)果為 an error

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

解析： 大多數(shù)人都會先看到三元運(yùn)算符，然后輸出結(jié)果Value is somethin
我也是這樣/(ㄒoㄒ)/~~
這里主要是考慮了優(yōu)先級。+ 的優(yōu)先級是高于 ? 的，
所以執(zhí)行順序是

val === "stmg" => true
"Value is" + true => "Value is true"
"Value is true " ? "Something" : "Nothing" => "Something"

所以結(jié)果為 "Something"

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

解析：主要考慮變量聲明提升，本題相當(dāng)于把name聲明到頂部但是未定義。
這里擴(kuò)充一下函數(shù)提升

dohois(); //"提升了"
donothois(); //TypeError: undefined is not a function
//函數(shù)聲明提升
function dohois () {
    console.log("提升了");
}

//函數(shù)表達(dá)式不提升
var donothois = function () {
    console.log("沒有提升");
}

所以結(jié)果為 Goodbye Jack

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

解析：JS里Math.pow(2, 53)是可以表示的最大值，最大值加1還是最大值。發(fā)生的情況是這樣的 ：Math.pow(2, 53) == Math.pow(2, 53) + 1，所以永遠(yuǎn)不可能大于Math.pow(2, 53)。

console.log(Infinity); //Infinity
console.log(Infinity + 1); //Infinity

所以結(jié)果是 無限循環(huán)

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

解析：首先需要理解稀疏數(shù)組和密集數(shù)組

創(chuàng)建一個(gè)稀疏數(shù)組，遍歷稀疏數(shù)組時(shí)，會發(fā)現(xiàn)這個(gè)數(shù)組并沒有元素，js會跳過這些坑。

//第一種情況
var a = new Array(3); 
console.log(a); //[, , ,]

//第二種情況
var arr = [];
arr[0] = 1;
arr[100] = 100;

a.map(function (x, i) {return i}); //[, , ,]

創(chuàng)建一個(gè)密集數(shù)組，可以遍歷到這些數(shù)組元素

var a = Array.apply(null, Array(3));
console.log(a); //[undefined, undefined, undefined]

a.map(function (x, i) {return i}); //[0, 1, 2]

這道題目里的數(shù)組是一個(gè)稀疏數(shù)組，不會遍歷到（從索引3-9）“坑”，這些索引都不存在數(shù)組中，會直接跳過這些坑。所以永遠(yuǎn)篩選不到等于undefined的值。

所以結(jié)果為 []

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

解析： js的浮點(diǎn)數(shù)運(yùn)算，不能精確的表達(dá)小數(shù)。什么時(shí)候會精確呢，都不知道( ╯□╰ )。

所以結(jié)果為 [true, false]

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是嚴(yán)格比較。

這里要考慮字符串。

var s_prim = "foo";
var s_obj = new String(s_prim);

console.log(typeof s_prim); //"String"
console.log(typeof s_obj); //"object"

所以不可能匹配到case，所以結(jié)果為 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"));

解析：和第九題類似，但是注意此時(shí)typeof String("A") === "string"

所以結(jié)果為 Case A

function isOdd(num) {
    return num % 2 == 1;
}
function isEven(num) {
    return num % 2 == 0;
}
function isSane(num) {
    return isEven(num) || isOdd(num);
}
var values = [7, 4, "13", -9, Infinity];
values.map(isSane);

解析：主要在于-9 % 2 == -1保留正負(fù)號。Infinity % 2得到的是NaN，但是注意NaN與所有值都不相等包括本身。

所以結(jié)果為 [true, true, true, false, false]

parseInt(3, 8)
parseInt(3, 2)
parseInt(3, 0)

解析：和第一題考察的概念一樣。2進(jìn)制里沒有數(shù)字3，radix為0時(shí)時(shí)10進(jìn)制

所以結(jié)果為 [3, NaN, 3]

Array.isArray( Array.prototype )

解析：Array.prototype本身是一個(gè)數(shù)組，這只能牢牢記住了~

所以結(jié)果為 [true]

var a = [0];
if ([0]) {
  console.log(a == true);
} else {
  console.log("wut");
}

解析：所有對象都是true，但是當(dāng)執(zhí)行a == true時(shí)會進(jìn)行隱式轉(zhuǎn)換。

所以結(jié)果為 false

[] == []

解析：2個(gè)引用的是同一個(gè)對象、函數(shù)、數(shù)組，則它們相等，如果引用的不是同一個(gè)對象、函數(shù)、數(shù)組，則不相同，即使這2個(gè)對象、函數(shù)、數(shù)組可以轉(zhuǎn)換成完全相等的原始值。

所以結(jié)果為 false

"5" + 3
"5" - 3

解析：考察字符串拼接

1 + - + + + - + 1

解析：從后面開始計(jì)算，首先得到一個(gè)正數(shù)（+1），然后往前都是符號的改變得到（-1 -1 -1 -1 +1 ），等于1+(+1)

所以結(jié)果為 2

var ary = Array(3);
ary[0]=2
ary.map(function(elem) { return "1"; });

解析： 稀疏數(shù)組，會跳過這些未被賦值的“坑”。所以只有ary[0]能被遍歷到

所以結(jié)果為 [1, undefined × 2]

function sidEffecting(ary) {
  ary[0] = ary[2];
}
function bar(a,b,c) {
  c = 10
  sidEffecting(arguments);
  return a + b + c;
}
bar(1,1,1)

解析：

so changing the variables changes arguments and changing arguments changes the local variables even when they are not in the same scope.
改變變量改變了arguments，改變argumnets也改變了本地變量，即時(shí)他們不在一個(gè)作用域。

arguments就是傳進(jìn)來的參數(shù)組成的類數(shù)組。所以sidEffecting([a, b, c])，就知道a和c都為10，b為1。
ヽ(*。>Д<)o゜
但是當(dāng)函數(shù)參數(shù)涉及到 any rest parameters, any default parameters(默認(rèn)參數(shù)) or any destructured parameters 的時(shí)候, 這個(gè) arguments 就不在是一個(gè) mapped arguments object 了

function sidEffecting(ary) {
  ary[0] = ary[2];
}
function bar(a,b,c=3) {
  c = 10
  sidEffecting(arguments);
  return a + b + c;
}
bar(1,1,1) //12

所以結(jié)果為 21

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

解析：由于JS能表示整數(shù)范圍為-2^53~2^53，這里的a已經(jīng)超過了2^53，與第六題類似，最大值加上一個(gè)數(shù)還是最大值。所以還是a

所以結(jié)果為 a

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

解析：最后會返回這個(gè)調(diào)用者（this），x執(zhí)行的時(shí)候的上下文是全局，所以返回的是window。

所以結(jié)果為 window

Number.MIN_VALUE > 0

解析：Number.MIN_VALUE 屬性表示在 JavaScript 中所能表示的最小的正值。MIN_VALUE 屬性是 JavaScript 里最接近 0 的正值，而不是最小的負(fù)值。

所以結(jié)果為 true