被锤的面试题

以下注释都是自己的猜想，并不是正确的

1.

var a = 1;
if(!(b in window)){
  var b = 2;
  a+=1;
}else{
  a+=2
}
console.log(a);
console.log(b);

//这里我觉得就是3和undefined，因为var变量提升的原因，window全局是包含b的，所以第一个if语句永远进不去

2.

var m = 1;
function log(){
  var m = 2;
  return function(){
    m+=1;
  }
}
var _log = log();
_log();
console.log(m);

//结果是1，没有改变this

3.

for(var i = 0;i<5;i++){
  (function(){
    setTimeout(function(){
      console.log(i);
    },1000)
  })(i)
}

//输出五个5。去掉这个匿名函数我是知道输出5个5的，还需要重新复习下匿名函数（待完善）

4.

function fun(){};
console.log(typeof fun); //Function
console.log(fun instanceof Function); //true
console.log(fun instanceof Object); //true

//万物皆对象

5.

var a = 1;
var obj = {
  a:2,
  getA:function(){
    return this.a;
  }
}
console.log(obj.getA()); //2
console.log(obj.getA.call()); //1(这里的疑问：空参数会默认给全局的this么？)
console.log(obj.getA.call({a:10})); //10

6.

var arr = [1,2,3];

function test(arr){

  arr = [];

}

test(arr);
console.log(arr);

//被坑了，我的猜想这是作用域链的问题。test内部arr是有参数的，所以arr置空影响的是参数。如果参数不叫arr而是arr2的话，那么执行test时arr会找不到，然后沿着作用域链找到外层的arr，然后改变外层的arr

7.构造函数Fn，原型对象，实例对象三者之间的关系

每创建一个函数，该函数都会自动带有一个prototype属性。该属性是一个指针，指向一个对象，该对象称之为原型对象(后期我们可以使用这个原型对象帮助我们在js中实现继承).

原型对象上默认有一个属性constructor,该属性也是一个指针，指向其相关联的构造函数。

通过调用构造函数产生的实例对象，都拥有一个内部属性，指向了原型对象。其实例对象能够访问原型对象上的所有属性和方法。

总结：三者的关系是，每个构造函数都有一个原型对象，原型对象上包含着一个指向构造函数的指针，而实例都包含着一个指向原型对象的内部指针。通俗的说，实例可以通过内部指针访问到原型对象，原型对象可以通过constructor找到构造函数。

8.var const let区别

var：变量提升，可提前声明但不赋值

let:块级作用域，在当前{}内有效

const：定义变量不可修改，但可初始化。我的见解是const其实是规定了内存地址，如果你在这里定义的是对象或者数组是可以修改数组内容的:

const arr = [1,2];
arr.push(1);
console.log(arr); //【1，2，1】
arr = [2,3];
console.log(arr); // Error

9.实现一个bind

Function.prototype.testBind = function(that){
    var that = this,
        slice = Array.prototype.slice,
        args = slice.apply(arguments,[1]);
    return function(){
        return _this.apply(that,
                    args.concat(Array.prototype.slice.apply(arguments,[0]))
                )
    }    
}

10. 

function Foo(){
  getName = function(){
    console.log(1)
  }
  return this;
}
Foo.getName = function(){
  console.log(2)
};
Foo.prototype.getName = function(){
  console.log(3)
}
var getName = function(){
  console.log(4)
}

//输出结果
Foo.getName();  //2
getName();  //4
Foo().getName(); //1
getName(); //1
new Foo.getName(); //2
new Foo().getName(); //3 
new new Foo().getName(); //3