你真的了解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