——记25道JS题目

1.下面在控制台的输出是什么？？

console.log( [typeof null , null instanceof Object] )
/* 我们知道JS中变量类型分为值类型和引用类型。typeof 可以识别出
 undefined、string、number、boolean 四种值类型，{}、[]、null
都是返回 'object'，函数则返回'function'。另外，symbol类型也可以识别返回'symbol'。
A instanceof B方法则是判断A的原型链上是否有B的原型。
比如 [] instanceof Array 返回 true， 明显此处null instanceof Object返回false。 
 结果为 ["object", false]  */

2.下面在控制台的输出是什么？？

[]["map"]+[1,2]
// 空数组的"map"属性是函数，'+'连接引用类型是字符串拼接。
// 所以 'function map(){...}1,2'
[]["a"]+[1,[2,3]] 
// 空数组的"a"属性是undefined，与数组拼接，结果为'undefined1,2,3'
[]['push'](1) 
// []['push'](1) => [].push(1)，返回数组长度'1'
(![]+[])[+[]] 
// ![] => false，+[] => 0，false + [] => 'false'，
// 空数组转为数字是0，'false'[0] 为 'f'
(![]+[])[+!![]]
// ![]为false，!![]则为true，Number(true) => 1；('false')[1] => 'a'
++[[]][+[]] + [+[]] 
// ++[[]][0] + [0]， 1 + [0] => '10'
[1 < 2 < 3, 3 < 2 < 1]
//  1 < 2 < 3 => false < 3 => 0 < 3 => true， 同样[true, true]

3.阅读以下代码，下面的输出是什么？？

var a = 1,
    b = c = 0;
function add(n){
    return n=n+3;
}
y = add(a);
function add(n){
    return n=n*5;
}
z = add(a);
console.log(y,z);
// 变量提升， y = 5; z = 5 结果为5 5

4.阅读以下代码，下面的输出是什么？？

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;
    case new String('A'):
        console.log( new String('A') );
        break;
    default:
        console.log('Do not know!');
    }
}
showCase(new String('A'));
// new String('A')是一个字符串对象，没有选项与之全等，输出'Do not know!'。      

5.以下代码在控制台的输出是什么??

parseInt(3, 8)
parseInt(3, 2)
parseInt(3, 0)
// 把八进制的3转换为十进制的3；二进制中没有3为NaN；
// 进制数的区间[2, 36]，不在范围内为NaN，0默认是十进制，为3。

6.以下代码在控制台的输出是什么??

["1", "2", "3"].map(parseInt)
// parseInt('1', 0)  1
// parseInt('2', 1)  NaN
// parseInt('3', 2)  NaN
// ["1", "2", "3"].map(e => parseInt(e)) 如果指定参数则结果为[1,2,3]

7.以下代码在控制台的输出是什么??

function fn(ary) {
  ary[0] = ary[2];
}
function bar(a,b,c) {
  c = 10
  // 实参列表为[1, 1, 10]
  fn(arguments);
  // [10, 1, 10]
  return a + b + c;
}
bar(1,1,1)
// 21

8.以下代码在控制台的输出是什么??

function fn(){}
console.log(  Array.isArray(Array.prototype) ,Object.getPrototypeOf(fn) )
// 函数的原型是函数，数组的原型是数组，对象的原型是对象；
// Array.isArray(Array.prototype) => true
// Object.getPrototypeOf(fn) => fn.__proto__ = Function.prototype即一个函数

9.下面的输出是什么？？

(function(){
  var x = y = 1;
})();
console.log(y);  // 1
console.log(x);  // 未定义报错
// 预编译函数作用域中定义x，执行时y在父级作用域（全局）为1，x为1。执行结束x销毁。

10.下面的输出是什么？？

if(typeof c&&-true+ (+undefined)+''){
// 'undefined' && 'NaN'
    console.log('l am ok');
}
if(22+'33'*2==88){
// 88 == 88 true
    console.log('我还能做十道');
}
!!' '+!!'' -!!false||console.log('我选择go die');
// true+false-false => 1

11.下面的输出是什么？？

var length = 10;
function fn(){
    console.log(this.length);
}
var  obj = {
    length:5,
    method:function(){
        console.log(this.length);    //obj.length 5
        fn();            //window.length 10            
        arguments[0]();         //arguments长度为2        
    }
}
obj.method(fn,1)

12.下面的代码输出是什么？？

var a = { n:1 };        
var b = a;    
// a.n 还是指对象{n: 1} a是{m: 1}（运算符优先级）        
a.n = a = { m:1 };
console.log(a,b)
//a => {m: 1}  b => {n: {m: 1}}

13.下面的代码输出是什么？？

var x = 1
if(function fn(){}){
    x += typeof fn
}
//(function fn(){})
//!function fn(){}
//+function fn(){}
//-function fn(){}
//~function fn(){}
// 函数表达式没有名字，fn未定义
console.log(x);
// '1undefined'

14.下面的代码输出是什么？？

var x = 10;
function a(){
    y = function(){
        x = 2;
    }
    console.log(this); // window调用，this指向window
    return function(){
        var x = 3;
        y();  // y函数与父级函数内都没有x，将window的x赋为2
        console.log(this.x); // 2
    }.apply(this)
}
a();
console.log(y); // y是window中的函数

15.下面的代码输出是什么？？

typeof undefined=== typeof Undefined
//两边都是"undefined"  true 

16.下面的代码输出是什么？？

var a={},
b={key:'b'},
c={key:'c'};

a[b]=123; // a[object Object] = 123
a[c]=456; // a[object Object] = 456
// 对象和数组的键名都是字符串，b和c对象转为字符串都是"[object Object]"
console.log(a[b])

17.下面的代码输出是什么？？

var out = 25,
   inner = {
        out: 20,
        func: function () {
            var out = 30;
            return this.out;
        }
    };
console.log((inner.func, inner.func)());
// (inner.func, inner.func)得到后面的结果，自执行函数指向window, 25
console.log(inner.func());
// inner调用函数，this指向inner对象为 20
console.log((inner.func = inner.func)());
// 25 赋值后得到函数，然后运行； 同一，相当于var fn = inner.func; fn()

18.下面的代码输出是什么？？

if (!("a" in window)) { // window中是否有a属性
    var a = 1;  // 变量提升， window中a为undefined；如果为let，则a不存在报错
}
alert(a); // 'undefined'

19.下面代码的输出是什么？？

var fn = function test(){
    console.log('代码执行了')
}
test()
// 语法错误、引用错误、类型错误，此处是引用错误，test未定义。

20.下面的代码输出是什么？？

var str = typeof typeof {name:'heaven'};
// 两个typeof 一定是'string'，str = 'string'
if( str.length==6 ){
    str.prop = '这是一波字符串';
//包装类执行完之后，立即销毁，所以再打印是没有结果的，'undefined'。
}
console.log(str.prop)

21.下面的代码输出是什么？？

function fun(n,o) {
    console.log(o);
    return {
        fn:function(m){
            return fun(m,n);
        }
    };
}

var a = fun(0);    
// a = { fn: function(){...} }
// 打印 undefined
a.fn(1); 
// 执行a.fn(1)，n为传进来的实参1，o为产生闭包时的赋值0。（fun(0)执行时的AO对象，o为0）
// 打印 0
a.fn(2); 
// 同样执行a.fn(2)，m为传进来的实参2，o为产生闭包时的赋值0。
// 打印 0
a.fn(3); 
// 同样执行a.fn(3)，m为传进来的实参3，o为产生闭包时的赋值0。
// 打印 0
var b = fun(0).fn(1).fn(2).fn(3);
// fun(0)执行，并返回对象{ fn: function(){...} }。打印 undefined
// fn(1)执行，n为传进来的实参m：1，o为产生闭包时的赋值0。打印 0 
// fn(2)执行，n为传进来的实参m：2，其作用域链有fn(1)执行时，o的赋值1。打印 1
// fn(3)执行，n为传进来的实参m：3，其作用域链有fn(2)执行时，o的赋值2。打印 2
var c = fun(0).fn(1); 
// fun(0)执行，并返回对象{ fn: function(){...} }。打印 undefined
// fn(1)执行，n为传进来的实参m：1，o为产生闭包时的赋值0。打印 0 
c.fn(2);
// fn(2)执行，n为传进来的实参m：2，其作用域链有fn(1)执行时，o的赋值1。打印 1
c.fn(3);
// fn(3)执行，n为传进来的实参m：3，其作用域链有fn(1)执行时，o的赋值1。打印 1

22.下面的代码输出是什么？？

var a = 1;
var b = 2[a,b] = [b,a]
// b = 2[1, undefined] = [undefined, 1]
// b = undefined = [undefined, 1]
console.log(a,b)
// 1 [undefined, 1]

23.下面的代码输出是什么？？

var n = 10;
var obj = {
    n : 5,
    c : a()  //c是一个函数，此时obj调用时this指向obj。
};
function a(){
    var n = 7;
    var c = function(){
        var n = 3;
        console.log(this.n)
    }
    return c;
};
obj.c()     // 5        

/*********************/
function fn(a,b,c,d){}
fn.fn = function(){
    console.log(this.length)
}
fn.fn() //一个函数的length属性是形参个数。

24.下面的代码输出是什么？？

var arr = [1,3,5,7,9];
function fn(){
    this.arr = [2,4,6,8,10];
    arr.forEach( function(){
        console.log(this.arr);
    } );
}
new fn()
// 回调函数中的this一般都指向全局,遍历全局中的arr，并打印全局中的arr
// [1, 3, 5, 7, 9]
// [1, 3, 5, 7, 9]
// [1, 3, 5, 7, 9]
// [1, 3, 5, 7, 9]
// [1, 3, 5, 7, 9]

25.下面的代码输出是什么？？

function test (){
    var n = 4399;
    function add(){
        n ++;
        console.log(n)
    };
    return {
        n,
        add
    }
}
var result1 = test();
// { n: 4399, add: function(){...} }
var result2 = test();
// { n: 4399, add: function(){...} }
result1.add();
// 函数执行，打印出 4400
result1.add();
// 函数执行，打印出 4401
console.log(result1.n);
// 4399
result2.add();
// 4400 
// 分别产生两个闭包，对闭包中的n进行n ++ 操作