解析js面试题(上）
注：本篇博客的题目出自于博主，小平果118博客，题目地址：http://blog.csdn.net/i10630226/article/details/49765737，由于该博客并没有抛出来来答案和解析，我在这里以自己的理解来做一下这些题目。欢迎大家与我交流！下面进入正题，来看题目：
1，以下表达式的运行结果是：
["1","2","3"].map(parseInt)
A.["1","2","3"]
B.[1,2,3]
C.[0,1,2]
D.其他 这道题考的非常细致，答案应该是 D ，输出的为[1, NaN, NaN]
解析：这道题我们需要注意的parseInt函数的参数，这个函数的参数有两个，一个是必须参数，也就是需要被解析的字符串；另一个是数字基数，是一个可选参数，如果我们传入的是0或者不传入的话，默认以十进制来解析，如果该参数小于 2 或者大于 36 ，则 parseInt() 将返回 NaN。
下面来看我们的题目，首先会是parseInt("1", 0)，正如我们以上所说以十进制来进行解析，所以就得到1，然后是parseInt("2", 1)，由于基数小于 2 ，返回的就是NaN，最后是parseInt("3", 2)，由于二进制的每位最大值只能够为 1 ，所以已二进制的形式来解析，显然也是错误的。
我们现在对题主给的这个函数做一下改变["1","2","3"].map(parseFloat)的话，我们会得到的是[1, 2, 3]，这是因为我们的parseFloat的参数只有一个，那就是被解析的字符串。
我们从这题可以看出parseFloat与parseInt的区别：
1. 前者返回一个浮点数；后者返回一个整数
2. 前者只能在十进制下解析，只有一个参数；后者可以在二进制到三十六进制下进行解析，有两个参数。
2，以下表达式的运行结果是：
[typeof null, null instanceof Object]
A.["object",false]
B.[null,false]
C.["object",true]
D.其他这题主要考的是null，答案为 B
解析：null只是一个空指针引用，个人的认知是typeof返回的只是基础数据类型，也就是Number，Null，Undefined，Boolean，String，Symbol，Object,在js中属于typeof null返回object可以说是一个历史错误，没有什么为什么，它就是这样。
然而instanceof却是十分有意思，其目的是检测一个对象是不是为另一个对象的实例，由于null只是一个空指针引用，所以null肯定不是有new Object()得到的，所以返回的false。
3，以下表达式的运行结果是：
[[3,2,1].reduce(Math.pow),[].reduce(Math.pow)]
A.报错
B.[9,0]
C.[9,NaN]
D.[9,undefined]这题，答案为 A
解析：因为调用空数组不带默认参数地调用reduce()方法会报错，当只有一个元素的时候（数组只有一个元素，且没有初始参数；数组为空，但是含有初始参数），reduce()方法只会简单的返回这个数值，而不会调用化简操作，但是我仍然需要知道一下前面的那个值为什么为 9 ，我们第一次调用函数时，第一个参数为初始值，假若没有初始值的话，则将数组的第一个元素作为初始值，我们第一次传入的参数就为 3,2 ，计算 32 得出 9 ，第二次传入的为第一次化简函数返回的值和数组下一个位置的值，也就是 9,1 ，所以最终输出 9 。
4，以下表达式的运行结果是：
var val = 'value';
console.info('Value id '+(val === 'value')?'Something':'Nothing');
A.Something
B.Nothing
C.NaN
D.其他这题答案是 A ，没有什么好解释的只有空字符串转化为Boolean类型时为false
5，以下表达式的运行结果是：
var name = 'World';
(function(){
if(typeof name === 'undefined'){
var name = "Jack";
console.info('Goodbye '+ name);
}else{
console.info('Hello ' + name);
}
})();
A.Goodbye Jack
B.Hello Jack
C.Goodbye undefined
D.Hello undefined这题答案为 A ，主要为变量提前声明，在es2015中的let,const并不会发生这种现象。
6，以下表达式的运行结果是：
var END = Math.pow(2,53);
var START = END - 100;
var count = 0;
for(var i = START ; i <= END ;i++){
count ++;
}
console.log(count);
A.0
B.100
C.101
D.其他答案是 D ，因为在js中可以允许的最大数值为 253 ，大于 253 的整数计算不能确保正确，但不一定总不正确，$，如：Math.pow(2, 53) + 1 === Math.pow(2, 53)返回值为true，所以我们写的那个就是一个死循环。
7，以下表达式的运行结果是：
var arr = [0,1,2];
arr[10] = 10;
arr.filter(function(x){return x === undefined});
A.[undefined x 7]
B.[0,1,2,10]
C.[]
D.[undefined]这题答案为 C ，因为fliter()方法会跳过稀疏数组中缺少的元素，所以中间的那些未定义就直接被跳过了，这也是数组某位置值为undefined与未定义的一个区别。
8，以下表达式的运行结果是：
var two = 0.2;
var one = 0.1;
var eight = 0.8;
var six = 0.6;
[two -one == one,eight- six == two];
A.[true,true]
B.[false,false]
C.[true,false]
D.其他这题答案为 C ，计算机在计算浮点数时有一个小bug，具体的详情可以参考我之前的博客：http://blog.csdn.net/zp1996323/article/details/48521699
9，以下表达式的运行结果是：
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'));
A.Case A
B.Case B
C.Do not know
D.undefined 答案为： C ，因为case的条件分支视为判断===，引用类型的String与基本类型的String由于类型不同，所以走的是default分支
10，以下表达式的运行结果是：
function showCase(value){
switch(value){
case 'A':
console.info('Case A');
break;
case 'B':
console.info('Case B');
break;
case undefined :
console.info('undefined');
break;
default:
console.info('Do not know!');
}
}
showCase(String('A'));
A.Case A
B.Case B
C.Do not know
D.undefined答案为 A ，将字符串强制类型转换为字符串，所以满足===，值等类型等。
11，以下表达式的运行结果是：
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);
A.[true, true, true, true, true]
B.[true, true, true, true, false]
C.[true, true, true, false, false]
D.[true, true, false, false, false]答案为 C ，-9 % 2余下的为-1，Infinity % 2得到的是NaN
12，以下表达式的运行结果是：
[parseInt(3,8),parseInt(3,2),parseInt(3,0)]
A.[3,3,3]
B.[3,3,NaN]
C.[3,NaN,NaN]
D.其他答案为 D ，我们得到的输出结果为[3, NaN, 3]，关于parseInt请参见第一题的解析。
13，以下表达式的运行结果是：
Array.isArray(Array.prototype)
A.true
B.false
C.报错
D.其他答案为 A ，因为我们的Array.prototype就是一个[]。
14，以下表达式的运行结果是：
var a = [0];
if([0]){
console.info(a == true);
}else{
console.info("else");
}A.true
B.false
C.”else”
D.其他
答案为 B ，我们需要清楚的是在if条件判断中会调用我们的强制类型转换，将其转换为boolean类型值，也就是说if条件判断中相当于对于条件进行Boolean(条件内容)，但是对于==来说，只是来进行值类型的比较，我们的[0]拿到的是其值，也就是0，这样显然不等于true。
15，以下表达式的运行结果是：
[]==[]
A.true
B.false
C.报错
D.其他答案为 B ，在js中两个对象是永远不可能相等的，因为对象是引用类型，其意义等同于指针，正如题目中的两个空数组那样，虽然都是空数组，但是它们在内存中的地址并不同，所以值，也就是指针肯定不同。
16，以下表达式的运行结果是：
[('5'+3),('5'-3)]
A.["53",2]
B.[8,2]
C.报错
D.其他答案为 A ，老生常谈的问题，字符串与数值进行 + 操作时，会将number类型转换为string类型，进行 − 操作时，会将string类型转换为number类型。
17，以下表达式的运行结果是：
1+-+++-+1
A.true
B.false
C.报错
D.其他 如果题目是长成这个样的话，那么会报错，答案也就是 D ，但是假如题目是：
1 + - + + + - + 1那么输出结果为 2 ，为什么会为 2 呢？这表达式运算符之间存在空格，也就是说上面的表达式相当于1 + "" - "" + "" + "" + "" - "" + 1，在结合我在十六题时所说，很容易就能算出。
18，以下表达式的运行结果是：
var arr = Array(3);
arr[0] = 2
arr.map(function(elem){return '1';});
A.[2,1,1]
B.["1","1","1"]
C.[2,"1","1"]
D.其他答案为 D ，输出的应该为["1", ,]，map方法与我们之前所看到的filter方法一样，会跳过缺失的元素，所以稀疏数组经过map处理后仍然为稀疏数组。
19，以下表达式的运行结果是：
function sidEffecting(arr){
arr[0] = arr[2];
}
function bar(a,b,c){
c = 10;
sidEffecting(arguments);
return a+b+c;
}
bar(1,1,1);
A.3
B.12
C.报错
D.其他答案为 D ，其结果为 21 。
20，以下表达式的运行结果是：
var a = 111111111111111110000;
b = 1111;
console.info(a+b);
A.111111111111111111111
B.111111111111111110000
C.NaN
D.Infinity 答案为 B ，像我们之前第六题那样，变量a的值已经超过了Math.pow(2, 53)，所以容易产生精度丢失问题。
21，以下表达式的运行结果是：
ar x = [].reverse;
x();
A.[]
B.undefined
C.报错
D.window答案为 D ，首先我们知道用数组的reverse方法操作数组，数组将会被改变，可以出名reverse是操作this，并且返回this，如：
[].reverse.call(new Boolean(true)); bool对象
[].reverse.call(new Number(23)); number对象所以我们可以确认的是，我们的reverse，将[].reverse赋值给一个全部变量x，所以调用我们的x时相当于window.x，所以this也就指向window了。
22，以下表达式的运行结果是：
Number.MIN_VALUE>0
A.true
B.false
C.报错
D.其他答案为 A ，Number.MIN_VALUE表示的一个无限接近于0的数字，值约为 5∗10−324 。