this-原型链-继承

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

作用：改变函数运行时 this 的指向

区别：

apply 调用一个函数，传入函数执行上下文及参数，第一个参数是希望设置的 this 的值，第二个参数接收参数数组
call 和 apply 很相似，不同之处在于 call 接收的不是参数数组，而是参数列表
bind 将函数内部的 this 传入作为参数，并返回一个新函数，使用时在需要调用的地方调用返回的新函数

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

var john = { 
  firstName: "John" 
}
function func() { 
  alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi() // John: hi!

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

func() 
function func() { 
  alert(this)
}

输出 window

函数 func 里的 this 严格来说是 undefined ，按照浏览器的规则「如果你传的 context 就 null 或者 undefined，那么 window 对象就是默认的 context」， window 就成了默认的 context

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

document.addEventListener('click', function(e){
    console.log(this);  // 这里输出 document 在事件处理程序中， this 代表事件源 DOM 对象
    setTimeout(function(){
        console.log(this);  // 这里输出 window 在 setTimeout 和 setInterval 这两个方法中 this 是全局对象
    }, 200);
}, false);

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

var john = { 
  firstName: "John" ![未命名文件.png](http://upload-images.jianshu.io/upload_images/6753264-779f0661d1de04c9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

}
function func() { 
  alert( this.firstName )
}
func.call(john)

输出 John

函数 func 内的 this 是全局对象，在调用 call 方法并将对象 john 作为 this 的值传入后， func 的 this指向了对象 john ，因此得到了上面的输出结果

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

var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指什么
      this.showMsg();
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}

第一个 this 指的是 DOM 元素 $btn

第二个 this 本意是指向对象 module ，这样 this.showMsg() 就可以调用函数 showMsg ，但由于 $btn 的事件处理程序中的 this 已经发生了变化，预想中的调用是失败的

修改如下

var module= {
  bind: function(){
    var _this = this
    $btn.on('click', function(){
      console.log(this)
      _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();

Person 是通过函数定义的类
prototype 是类在创建是自动获得的属性
constructor 是 prototype 属性下的一个方法(函数)，它又指向类，也就是 Person 本身
p 是 Person 的实例
__proto__ 是实例 p 的内部属性，它指向 Person 的 prototype 属性

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

首先对象 p 会在自己内部寻找 toString() 方法，找不到时，就在它的原型 Person 里找，如果原型中也没有就继续向上在原型的原型 Object 里找，Object 里包含 toString() 方法， p 也就能够调用 toString() 方法了。

image.png

每个对象都有属性和方法，当调用一个属性或方法时首先在对象内部寻找，如果找不到就向上到该对象的原型中寻找，如果还找不到，继续向上在原型的原型里寻找，以此类推，直到找到要调用的属性或方法，或者在最顶层原型里也找不到，返回 undefined。这就是原型链

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

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

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

instanceof 用于判断一个对象是不是某个类的实例

例如在 a instanceof b 中， a 通过 __proto__ 属性一层层向上寻找，看是否能找到原型 b，如果能找到， a 就是 b 的实例，反之则不是

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

继承可以让一个对象直接使用另一个对象的属性和方法

问题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 里，每次创建 People 的实例都要重新创建一次该方法，损耗了一部分性能

而方法2将方法 printName 绑定到 People.prototype 上，再创建实例时，都可以在需要的时候调用该方法，而不必每次都创建方法，即使不使用这个方法也不得不创建，节省了内存空间，提高了性能

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

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

Object.create() 是ES5方法,不兼容IE9以下

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

hasOwnProperty 是 Object.prototype 的一个方法，可以判断一个对象是否包含自定义属性而不是原型链上的属性， hasOwnProperty 是JavaScript中唯一一个处理属性但是不查找原型链的函数

例如要判断对象 o 的属性是自身属性还是继承属性，可以这样做

o = new Object();
o.prop = 'exists';
o.hasOwnProperty('prop');             // 返回 true
o.hasOwnProperty('toString');         // 返回 false
o.hasOwnProperty('hasOwnProperty');   // 返回 false

问题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;
}

通过在类 Male 中执行类 Person 的构造函数，就把 Person 到属性赋值到了 Male 内部，现在 Male 也可以调用 Person 到属性和方法了

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

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

Person.prototype.getName = function(){
    console.log(this.name)
};    

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

Male.prototype = Object.create(Person.prototype)
Male.prototype.constructor = Male

Male.prototype.getAge = function(){
    console.log(this.age)
};

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

this-原型链-继承