Xzavier's Blog | xiaohuazheng Blog

1.这个表达的结果是什么? ["1", "2", "3"].map(parseInt)

["1", "2", "3"] [1, 2, 3] [0, 1, 2] other

map对数组的每个元素调用定义的回调函数并返回包含结果的数组。["1","2","3"].map(parseInt)对于数组中每个元素调用paresInt。
map中回调函数的语法如下所示：function callbackfn(value, index, array1)，可使用最多三个参数来声明回调函数。第一参数value，数组元素的值；第二个参数index，数组元素的数组索引；第三个参数array1，包含该元素的数组对象。因此，题目等同于[parseInt(1,0),parseInt(2,1),parseInt(3,2)]最终返回[1, NaN, NaN]。

2.以下表达式的运行结果是? [typeof null, null instanceof Object]

["object", false] [null, false] ["object", true] other

typeof用以获取一个变量或者表达式的类型，typeof一般只能返回如下几个结果：
number,boolean,string,function（函数）,object（NULL,数组，对象）,undefined
instanceof 表示某个变量是否是某个对象的实例，null是个特殊的Object类型的值，表示空引用的意思。但null返回object这个其实是最初JavaScript的实现的一个错误，然后被ECMAScript沿用了，成为了现在的标准，不过我们把null可以理解为尚未存在的对象的占位符，这样就不矛盾了，虽然这是一种“辩解”。对于我们开发人员还是要警惕这种“语言特性”。最终返回：["object", false]。
传送门：数据类型判断

3.以下表达式的运行结果是? [ [3,2,1].reduce(Math.pow), [].reduce(Math.pow) ]

an error [9, 0] [9, NaN] [9, undefined]

pow(x, y) 方法可返回 x 的 y 次幂的值。执行Math.pow(3,2)和Math.pow(2,1)，最终返回9和9。但是要注意pow的参数都是必须的，[].reduce(Math.pow)，等同于执行 Math.pow(); 会抛出错误: TypeError

4.以下表达式的运行结果是?

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

Value is Something Value is Nothing NaN other

+运算符优先于三元运算符。先执行字符串拼接，再执行校验，返回Something。
传送门：详解运算符 & 运算符优先级

5.以下表达式的运行结果是?

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

Goodbye Jack Hello Jack Hello undefined Hello World

var声明被提升到函数作用域最前。判断语句被包裹在立即调用函数里，函数内部无法访问外部值为'World'的name，因此typeof name === 'undefined'为真，执行下一步操作，最终输出Goodbye Jack

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);

0 100 101 other

代码进入一个无限循环，2 ^ 53是javascript中规范的精度下能表示的最大数字，2 ^ 53 + 1 也返回 2 ^ 53的值，所以i永远不会变得比这个大。

7.以下表达式的运行结果是?

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

[undefined × 7] [0, 1, 2, 10] [] [undefined]

Array.prototype.filter不会调用没有被赋值的元素，即在ary中，长度为10但实际数值元素列表为[0, 1, 2, 10]，因此，最终返回一个空的数组[]。

8.以下表达式的运行结果是?

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

[true, true] [false, false] [true, false] other

JavaScript没有精确的数学运算，尽管有时它可以正常工作。严格来说，精确运算问题实际存在，各语言处理上不同罢了。 JavaScript中，两个浮点数相加或者相减，将会导致一定的正常的数据转换造成的精度丢失问题eight-six = 0.20000000000000007。JavaScript中的小数采用的是双精度(64位)表示的，由三部分组成：　符 + 阶码 + 尾数，在十进制中的 1/10，在十进制中可以简单写为 0.1 ，但在二进制中，他得写成：0.0001100110011001100110011001100110011001100110011001…（后面全是 1001 循环）。因为浮点数只有52位有效数字，从第53位开始，就舍入了。这样就造成了“浮点数精度损失”问题。更严谨的做法是(eight-six ).totoFiexd(1)或者用用Math.round方法回归整数运算。
传送门：为什么 0.1 + 0.2 != 0.3 ？

9.以下表达式的运行结果是?

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!');
            break;
    }
}
showCase(new String('A'));

Case A Case B Do not know! undefined

switch判断用的 ===，且 new String(x) !== x。使用new String()构造函数将调用一个全新的对象作为this变量的值，并且隐式返回这个新对象作为调用的结果，因此showCase()接收的参数为String {0: "A"}为不是我们所认为的A。
传送门：代码中的流程控制

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!');
            break;
    }
}
showCase(String('A'));

Case A Case B Do not know! undefined

String(x)不创建对象，返回一个字符串，即： typeof String(1) === "string"。
传送门：代码中的流程控制

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);

[true, true, true, true, true] [true, true, true, true, false] [true, true, true, false, false] [true, true, false, false, false]

isSane函数判断num是否为正整数，'13'被强制转换为数值13，-9 % 2结果为-1，Infinity % 2为NaN

12.以下三个表达式的运行结果是? parseInt(3, 8) parseInt(3, 2) parseInt(3, 0)

3, 3, 3 3, 3, NaN 3, NaN, NaN other

3无法按 2进制转换，所以返回 NaN，对于 0， parseInt数字将以 10 为基础来解析，所以返回 3。所以答案应该为：[3, NaN, 3]

13.以下表达式的运行结果是? Array.isArray( Array.prototype )

true false error other

Array.prototype是一个数组，Array.isArray(a)是一个判断a是否为数组的方法。

14.以下表达式的运行结果是?

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

true false "false" other

[0]会被认为是一个 truely值，在if条件判断语句相对于==比较宽松中，只要if(n)，n不为null，0，undefined，''值，都会认为是truely值。进入console.info(a == true);最终返回false。
传送门：代码中的那些判断

15.以下表达式的运行结果是? []==[]

true false error other

数组，在 Javascript 中是对象，对象使用 == 比较都是比较的引用。简单的说，就是，如果是同一个对象，就相等，如果不是同一个对象，就不等。每次使用 [] 都是新建一个数组对象，所以 [] == [] 这个语句里建了两个数据对象，它们不等。
传送门：代码中的那些判断

16.以下两个表达式的运行结果是? '5' + 3 ; '5' - 3

"53", 2 8, 2 error other

执行'5' + 3，加号具备拼接字符串功能，会将3强制转换为字符串'3'和'5'拼接。执行'5' - 3，减号只具备数值运算的功能，因此会将'5'转化为数值，进行 5 - 3的数值运算。
传送门：详解加法运算符

17.以下表达式的运行结果是? 1 + - + + + - + 1

2 1 error other

1 + (- (+ (+ (+ (- (+ 1))))))
传送门：详解加法运算符

18.以下表达式的运行结果是?

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

[2, 1, 1] ["1", "1", "1"] [2, "1", "1"] other

map仅对已被初始化的 Array的元素调用执行。区分赋值和声明。虽然var arr = Array(3);创建一个长度为3的数组，但是实际只有一个元素被赋值，因此arr的实际长度为1，即最终参与map的只有一个元素，返回[1] or ["1", undefined × 2](某些浏览器控制台)

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);

3 12 error other

return 10 + 1 + 10;返回值21，arguments值可以改变。

20.以下表达式的运行结果是?

var a = 111111111111111110000;
b = 1111;
console.info(a + b);

111111111111111111111 111111111111111110000 NaN Infinity

JavaScript精确整数最大为: Math.pow(2,53) = 9007199254740992。a的值大于javascript所能表示的最大整数精度，因此和任何数值相加将会导致失真。

21.以下表达式的运行结果是? var x = [].reverse; x();

[] undefined error window

正确调用方式为x.call([])

22.以下表达式的运行结果是? Number.MIN_VALUE > 0

false true error other

Number.MIN_VALUE表示的最小值为5e-324，MIN_VALUE代表的并不是负最小，而是最接近0的一个数，因此Number.MIN_VALUE > 0。负最小值可以使用-Number.MAX_VALUE表示。

23.以下表达式的运行结果是? [1 < 2 < 3, 3 < 2 < 1]

[true, true] [true, false] error other

1 < 2，返回true，执行true < 3，会强制将true转换为1，1 < 3，最终返回true。 3 < 2，返回false，执行false < 1,会强制将false转换为0，0 < 1，最终返回true。

24.以下表达式的运行结果是? 2 == [[[2]]]

true false undefined other

使用a == b判断a和b对象是否相等，可以会将b对象强制转换为a对象的类型，即执行2 == [[[2]]]，会调用[[[2]]].valueOf().toString()将[[[2]]]强制转化为基本类型，即'2'，2 == '2'也会再做一下转化，最终返回true。

25.以下三个表达式的运行结果是? 3.toString() ; 3..toString() ; 3...toString()

"3", error, error "3", "3.0", error error, "3", error other

Number中的toString(a)，能够将数值转化成为a进制的值。但a缺省时，默认转化为十进制。一般使用方法为：var n = 3;3.toString(); 执行3.toString()，因为3只是为数值型变量，为非Number实例，因此对于3不能直接调用Number方法。而执行3..toString()，会强制将3转化为数字实例，因此能够被解释，输出3，同样可以使用(3).toString()。

26.以下表达式的运行结果是?

(function(){
    var x = y =1;
})();
console.info(y);
console.info(x);

1, 1 error, error 1, error other

在立即调用函数内执行，var x = y =1;创建局部变量x和全局变量y。函数外部试图访问函数内部的变量，将会导致错误ReferenceError。

27.以下两个表达式的运行结果是?

var a = /123/, 
    b = /123/; 
console.log(a == b);
console.log(a === b);

true, true true, false false, false other

28.以下四个表达式的运行结果是?

var a = [1, 2, 3], 
    b = [1, 2, 3], 
    c = [1, 2, 4];
a == b;
a === b; 
a > c;
a < c

false, false, false, true false, false, false, false true, true, false, true other

数组用 >和 <是按照字典顺序进行比较, 但不能用 ==和 ===进行比较

29.以下表达式的运行结果是?

var a = {}, 
    b = Object.prototype; 
[a.prototype === b, Object.getPrototypeOf(a) === b]

[false, true] [true, true] [false, false] other

函数都有一个prototype属性，但不是所有Object都是这样，a.prototype是undefined。每个Object都有一个可以通过Object.getPrototypeOf访问的内部属性。
传送门：对象使用

30.以下表达式的运行结果是?

function f() {} 
var a = f.prototype, 
    b = Object.getPrototypeOf(f); 
a === b

true false null other

f.prototype是任何用 new f创建的对象的父对象，而 Object.getPrototypeOf返回继承层次结构中的原型对象。比如数字继承自Number，字符串继承自String。
传送门：对象使用

31.以下表达式的运行结果是?

function foo() { } 
var oldName = foo.name; 
foo.name = "bar"; 
[oldName, foo.name]

error ["", ""] ["foo", "foo"] ["foo", "bar"]

函数的name是一个只读属性，但JavaScript并没有让赋值语句报错，而是直接忽略。

32.以下表达式的运行结果是? "1 2 3".replace(/\d/g, parseInt)

"1 2 3" "0 1 2" "NaN 2 3" "1 NaN 3"

String.prototype.replace的回调parseInt接收多个参数，第一个是捕获组的每一个参数，然后是匹配的子字符串的偏移量，最后是原始字符串本身的偏移量。所以parseInt将调用这些参数： [1, 0], [2, 2], [3, 4]。所以返回值："1 NaN 3"。

33.以下表达式的运行结果是?

function f() {} 
var parent = Object.getPrototypeOf(f); 
f.name // ? 
parent.name // ? 
typeof eval(f.name) // ? 
typeof eval(parent.name) // ?

"f", "", "function", "function" "f", undefined, "function", error "f", "", "function", "undefined" other

函数的name是一个只读属性，可访问。Object.getPrototypeOf返回继承层次结构中的原型对象，就是它自己。

34.以下表达式的运行结果是?

var lowerCaseOnly = /^[a-z]+$/; 
[lowerCaseOnly.test(null), lowerCaseOnly.test()]

[true, false] error [true, true] [false, true]

test的参数被隐式转换为一个字符串，所以表达式中的参数被转换成了： "null"和 "undefined"。所以返回[true, true]

35.以下表达式的运行结果是? [,,,].join(", ")

", , , " "undefined, undefined, undefined, undefined" ", , " ""

JavaScript中，数组允许有一个尾随的逗号。所以[,,,].length === 3，所以答案为：", , "

36.以下表达式的运行结果是? var a = {class: "Animal", name: 'Fido'}; a.class

"Animal" Object an error other

这取决于浏览器。 class是一个保留字，但它被Chrome，Firefox和Opera等接受可以作为属性名称。 IE则不行。

37.以下表达式的运行结果是? new Date("epoch")

Thu Jan 01 1970 01:00:00 GMT+0100 (CET) current time error other

返回值： Invalid Date。 new Date()构造函数这四种形式有效：
new Date(); new Date(value); new Date(dateString); new Date(year, month[, day[, hour[, minutes[, seconds[, milliseconds]]]]]);如果没有输入任何参数，则Date的构造器会依据系统设置的当前时间来创建一个Date对象。如果提供了至少两个参数，其余的参数均会默认设置为1（如果没有提供day参数）或者0。如果传入的是字符串，该字符串应该能被 Date.parse() 方法识别。

38.以下表达式的运行结果是?

var a = Function.length, 
    b = new Function().length;
a === b

true false error other

Function.length定义为1。另一方面，Function原型对象的length属性定义为0。

39.以下表达式的运行结果是?

var a = Date(0); 
var b = new Date(0); 
var c = new Date(); 
[a === b, b === c, a === c]

[true, true, true] [false, false, false] [false, true, false] [true, false, false]

Date，当它作为一个函数被调用时，Date(0);，它返回一个当前时间的字符串。被调用为构造函数时，new Date(0);，它将返回一个相对于该纪元的对象Thu Jan 01 1970 08:00:00 GMT+0800 (CST)。当缺少参数时，返回当前日期。如果没有输入任何参数，则Date的构造器会依据系统设置的当前时间来创建一个Date对象。

40.以下表达式的运行结果是?

var min = Math.min(), 
    max = Math.max()；
min < max

true false error other

当没有提供参数时， Math.min返回 +Infinity， Math.max返回 -Infinity。

41.以下表达式的运行结果是?

function captureOne(re, str) {
  var match = re.exec(str);
  return match && match[1];
}
var numRe  = /num=(\d+)/ig,
    wordRe = /word=(\w+)/i,
    a1 = captureOne(numRe,  "num=1"),
    a2 = captureOne(wordRe, "word=1"),
    a3 = captureOne(numRe,  "NUM=2"),
    a4 = captureOne(wordRe,  "WORD=2");
[a1 === a2, a3 === a4]

[true, true] [false, false] [true, false] [false, true]

如果使用/g标志符，则正则表达式在匹配时会携带lastIndex状态，即使它作用于不同的字符串。所以a3值为null。

42.以下表达式的运行结果是?

var a = new Date("2014-03-19"),
    b = new Date(2014, 03, 19);
[a.getDay() === b.getDay(), a.getMonth() === b.getMonth()]

[true, true] [true, false] [false, true] [false, false]

JavaScript中，Date的month是从0开始计算的，day，即今天是一周的第几天，是从周日-0开始计算的。new Date()，传的字符串需要被 Date.parse() 方法识别，字符串中的月份按正常值传即可。如果是按多参数传值，月份则需要按0-索引的形式传至。所以，上面代码改为：b = new Date(2014, 02, 19)，则返回：[true, true]。

43.以下表达式的运行结果是?

if ('http://giftwrapped.com/picture.jpg'.match('.gif')) {
  'a gif file'
} else {
  'not a gif file'
}

'a gif file' 'not a gif file' error other

String.prototype.match隐式地将字符串转换成一个正则表达式 /.gif/： /.gif/.test('/gif') === true。
传送门：正则表达式

44.以下表达式的运行结果是?

function foo(a) {
    var a;
    return a;
}
function bar(a) {
    var a = 'bye';
    return a;
}
[foo('hello'), bar('hello')]

["hello", "hello"] ["hello", "bye"] ["bye", "bye"] other

在函数中，声明变量和参数变量是一样的时候，声明变量会被挂起或者说是删除。再结合声明提升理解，且参数变量是可以被改变赋值的。所以foo('hello') 返回hello，bar('hello') 返回bye