你真的了解javascript吗？（一）

原题出处：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