this 相关问题

问题1： apply、call 、bind有什么作用，什么区别

**apply 和 call **
在 JavaScript 中，call 和 apply 都是为了改变某个函数运行时的上下文（context）而存在的，换句话说，就是为了改变函数体内部 this 的指向。它们的作用都是一样的，就是传递的参数不一样。
apply 接受2个参数，第一个参数指定了函数体内this对象的指向，第二个参数为数组或者一个类数组，而call则作为call的参数传入（从第二个参数开始），如果call方法没有参数，或者参数为null或undefined，则等同于指向全局对象

func.call(this,3,4,5)
func.apply(this.[3,4,5])

所以，一般当参数数量固定的时候用call不固定时用apply

bind
bind() 方法与 apply 和 call 很相似，也是可以改变函数体内 this 的指向。
MDN的解释是：bind()方法会创建一个新函数，称为绑定函数，当调用这个绑定函数时，绑定函数会以创建它时传入 bind()方法的第一个参数作为 this，传入 bind() 方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数。

var func = function(){
    console.log(this.x);
    console.log(arguments);
}
func();  // undefined, {}
var obj = {
    x: 2
}
var bar = func.bind(obj,1);
bar(); // 2 , {'0':1}

总结

• apply 、 call 、bind 三者都是用来改变函数的this对象的指向的；
• apply 、 call 、bind 三者第一个参数都是this要指向的对象，也就是想指定的上下文；
• apply 、 call 、bind 三者都可以利用后续参数传参；
• bind 是返回对应函数，便于稍后调用；apply 、call 则是立即调用 。

问题2： 以下代码输出什么?

var john = { 
  firstName: "John" 
}
function func() { 
  alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()//窗口弹出"John:'hi'"
//利用转化代码（下同） john.sayHi()相当于john.sayHi.call(john),this指向john

问题3： 下面代码输出什么，为什么

func() 
function func() { 
  alert(this)
} //窗口弹出“window”
//func() 可以简写为fun.call(undefined),call方法参数为null或undefined，则等同于指向全局对象

问题4： 下面代码输出什么，为什么

document.addEventListener('click', function(e){
    console.log(this);//输出“document”,this指向调用该函数的document节点
    setTimeout(function(){
        console.log(this);//输出“Window”，setTimeout函数中的this指向全局对象
    }, 200);
}, false);

问题5： 下面代码输出什么，为什么

var john = { 
  firstName: "John" 
}
function func() { 
  alert( this.firstName )
}
func.call(john) //窗口弹出“John”，this指向john对象

问题6： 以下代码有什么问题，如何修改

var module= {
  bind: function(){
var  _this = this //修改部分
    $btn.on('click', function(){
      console.log(this) //this指向全局对象，window
      _this.showMsg();//修改部分
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}

原型链相关问题

问题7：有如下代码，解释Person、 prototype、proto、p、constructor之间的关联。

function Person(name){
    this.name = name;
}
Person.prototype.sayName = function(){
    console.log('My name is :' + this.name);
}
var p = new Person("若愚")
p.sayName();

p 是Person的一个实例，Person的prototype相当于由其构造的实例的属性方法的公共容器，p的proto指向Person的prototype，Person的prototype里的proto指向Object的prototype，Person的prototype里的constructor既是Person本身

问题8： 上例中，对对象 p可以这样调用 p.toString()。toString是哪里来的? 画出原型图?并解释什么是原型链。

在js中，一切皆对象，每个对象都有一个指向它的原型的的内部链接(此链接还没有规范的访问方式，一般用__proro__代替),这个原型也有自己的原型，直到每个对象的原型为null为止，这就是原型链。toString()可以通过p.__proro__（指向Person.prototype）.__proro__（指向Object.prototype）找到这个方法，所以p可以调用toString()

问题9：对String做扩展，实现如下方式获取字符串中频率最高的字符

var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
String.prototype.getMostOften=function(){
   var obj = {}
   for(var i = 0,j;i<this.length;i++){
      j = this[i]
      if(obj[j]){
        obj[j]++
      }else{
        obj[j] = 1
      }
   } 
   var max=0
   var key=0
    for(var k in obj){
        if(obj[k]>max){
          max = obj[k]
          key = k
        }
    }
    return key
}
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次

问题10： instanceOf有什么作用？内部逻辑是如何实现的？

instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。instanceOf会判断对象的.proto是否等于构造函数的原型，如果不等，再判断对象的proto.__proto__;直到null，如果都不等，则对象不是构造函数的实例。

继承相关问题

问题11：继承有什么作用?

JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性或方法时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依此层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。这样可以实现代码重用，节省内存，子类新增属性或者方法也不会影响父类。

问题12： 下面两种写法有什么区别?

//方法1
function People(name, sex){
    this.name = name;
    this.sex = sex;
    this.printName = function(){
        console.log(this.name);
    }
}
var p1 = new People('饥人谷', 2)

//方法2
function Person(name, sex){
    this.name = name;
    this.sex = sex;
}

Person.prototype.printName = function(){
    console.log(this.name);
}
var p1 = new Person('若愚', 27);

方法1的printName()放在People的实例对象中，无法通过原型链来继承调用，方法2中的printName()放在People的prototype中，可以通过原型链来继承、调用，从而节省内存。

问题13： Object.create 有什么作用？兼容性如何？

Object.create() 方法使用指定的原型对象和其属性创建了一个新的对象。
用法：

function inherit(superType, subType){
    var _prototype  = Object.create(superType.prototype);
    _prototype.constructor = subType;
    subType.prototype = _prototype;
}

兼容性：

兼容性

问题14： hasOwnProperty有什么作用？ 如何使用？

hasOwnPerperty是Object.prototype的一个方法，可以判断一个对象是否包含自定义属性而不是原型链上的属性。

m.hasOwnProperty('name'); // true
m.hasOwnProperty('printName'); // false
Male.prototype.hasOwnProperty('printAge'); // true

问题15：如下代码中call的作用是什么?

function Person(name, sex){
    this.name = name;
    this.sex = sex;
}
function Male(name, sex, age){
    Person.call(this, name, sex);    //这里的 call 有什么作用
    this.age = age;
}

这里的 call 的作用是将执行上下文(context)的环境切换到Person下，也就是将Person的属性赋值给Male

问题16： 补全代码，实现继承

function Person(name, age){
    this.name = name
    this.age = age
}

Person.prototype.getName = function(){
    console.log('my name is'+ this.name)
};    

function Male(name, sex, age){
   Person.call(this,name,age)
  this.sex = sex
}

Male.prototype =Object.create(Person.prototype)
Male.prototype.constructor = Male
Male.prototype.getAge = function(){
    console.log('my age is '+this.age)
};

var ruoyu = new Male('若愚', '男', 27);
ruoyu.getName();