原型与原型链

apply、call 、bind有什么作用,什么区别

call方法使用給定的this参数以及分別給定的参数來调用某个函数,语法如下

fun.call(thisArg[, arg1[, arg2[, ...]]])
//thisArg为fun运行时指定的this值
//arg1,arg2为函数参数

示例用法

window.color = 'red'
let obj = {color: 'blue'}
function sayColor() {
  console.log(this.color)
}

sayColor() //    red,在全局中调用,this指向window
sayColor.call(obj)  // blue,call指定了this为obj
var array = [1,3,7,10]
Math.max.call(null,1,3,7,10)  //10,借用Math.max()方法

apply与call的功能是一样的,区别在于call方法接受的是若干个参数的列表,而apply方法接受的是一个包含多个参数的数组

var array = [1,3,7,10]
Math.max.apply(null,array)  //10,借用Math.max()方法

bind函数会创建一个新函数(称为绑定函数),新函数与被调函数(绑定函数的目标函数)具有相同的函数体(在 ECMAScript 5 规范中内置的call属性)。当目标函数被调用时 this 值绑定到 bind() 的第一个参数,该参数不能被重写。绑定函数被调用时,bind() 也接受预设的参数提供给原函数

window.color = 'red'
let obj = {color: 'blue'}
function sayColor() {
  console.log(this.color)
}
let sayColor1 = sayColor.bind(obj)
sayColor()    //red
sayColor1()  //blue

以下代码输出什么?

var john = { 
  firstName: "John" 
}
function func() { 
  alert(this.firstName + ": hi!")
}
john.sayHi = func    //john对象上添加属性sayHi,指向func这个函数
john.sayHi()    //'John: hi!'
//john对象中的sayHi方法中的this指向john

下面代码输出什么?为什么?

func()   //window;
function func() {  //全局作用域中this指向window
  alert(this)
}

下面代码输出什么?

document.addEventListener('click', function(e){
    console.log(this);     //document
    setTimeout(function(){
        console.log(this);      //window
    }, 200);
}, false);
//事件中的this指向发生事件的目标元素
//setTimeout和setIntval调用的函数中的this都指向window

下面代码输出什么?为什么?

var john = { 
  firstName: "John" 
}

function func() { 
  alert( this.firstName )
}
func.call(john)   //'John'
//通过call方法调用的函数改变了其this的指向,指向call中传递的context
//这个例子中context为john,于是func中的this就指向join

以下代码有什么问题,如何修改

var module= {
  bind: function(){
    $btn.on('click', function(){
      console.log(this) //this指什么
      this.showMsg();
    })
  },
  
  showMsg: function(){
    console.log('饥人谷');
  }
}
//例中的this指向$btn,事件中的this指向发生事件的目标事件
//因此this.showMsg()不存在,会报错
//修改
var module= {
  bind: function(){
    let _this = this    //保存最初的this
    $btn.on('click', function(){
      console.log(_this)
      _this.showMsg();
    })
  },

  showMsg: function(){
    console.log('饥人谷');
  }
}

有如下代码,解释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是一个构造函数,p是通过new Person建造的Person的实例
每一个构造函数都会有一个prototype,是这个函数的原型对象
prototype中默认都会有一个constructor属性,指向这一个构造函数
在本例中,Person的prototype有constructor,指向Person,还有一个sayName方法
p是Person通过new创建的实例,其中有一个__proto__这么个属性,这个属性指向了构造函数的prototype,本例中指向了Person的prototype

看图更直接!

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

toString是继承而来,详见下图

什么关系

p调用toString方法,先从它本身开始寻找,没有找到,便向上来到Person.prototype中寻找,也没有找到。
因为prototype本身是个对象,一切对象都是Object的实例,prototype也不例外,因此prototype中也有__proto__这么属性,指向了Object的原型对象。
因此当在寻找toString方法时,在Person.prototype中没有找到,就会进入Object.prototype中寻找,最终找到该方法,调用之。

这样一层层关系相互链接,层层关系递进,构成了实例与原型的链条,称为原型链

对String做扩展,实现如下方式获取字符串中频率最高的字符

var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次
String.prototype.getMostOften = function {
    let strArray = this.split('')
    let obj = {}
    let a = 0
    let maxKey
    strArray.forEach((item,index) => {
        if(obj[item]){
            obj[item]++
        } else {
            obj[item] = 1
        }
    })
    for(let key in obj) {
        if(obj[key] > a) {
            a = obj[key]
            maxKey = key
        }
    }
    return maxKey
}

instanceOf有什么作用?内部逻辑是如何实现的?

object instanceof constructor

instanceof运算符用来测试一个对象(object)的原型链上是否有某个构造函数(constructor)的原型(prototype)
如上面的Person例子

p instanceOf Person  //true
//p.__proto__  === Person.prototype,因此返回true
p instanceOf Object  //true
//p.__proto__.proto__  === Object.prototye,因此返回true

其内部逻辑是,看看检测对象上是否有指定的构造函数的原型,有则返回true,反之为false。
instanceOf运算符会一直寻找到原型链的尽头

继承有什么作用?

在ECMAScript中,原型链作为实现继承的主要方法
为什么要继承?继承可以让一个对象得以使用另一对象的属性和方法,而不用重新创建,达到重用的目的
这里示例一个使用原型链实现继承的基本例子

function Person(name) {
    this.name = name
}
Person.prototypr.sayName = function () {
    alert(this.name)
}
function Male(name,age) {
    //继承Person的属性
    Person.call(this,name)
    this.age = age
}

//怎么样才能让Male的实例拥有Person的sayName方法呢
Male.prototype = new Person()
let male1 = new Male()

下面两种写法有什么区别?

//方法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,每次new一个对象时,printName方法都会创建一次,new100次,创建100次printName方法
对于方法2,printNmae方法放在了Person的原型对象中,由于Person实例中的__proto__会指向Person的原型对象,这样所有的实例都可以访问到printName方法,printName只创建了一次

Object.create 有什么作用?兼容性如何

Object.create可以改变一个对象指向的原型
其接受两个参数,1.用作新对象原型的对象,2.(可选的)一个为新对象定义额外属性的对象

let person = {
    name: 'Jack',
    age: 20
}
let obj = Object.create(person)
obj.__proto__=== person  // true

Object.create是ES5新方法,支持ES5的引擎都能使用该方法

hasOwnProperty有什么作用?如何使用?

hasOwnProperty可以判断一个属性或者方法是本身具有还是通过原型链继承而来
hasOwnProperty只在属性存在于实例中时才返回true

//语法
Object.hasOwnProperty(attributeName)

如下代码中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起到继承属性的作用
call可以改变函数中this为指定的值
当new Male时,Male中的this指向创建的对象,call把Person中的this设置为创建的对象,达到继承Person属性的目的

补全代码,实现继承

function Person(name, sex){
    // todo ...
}

Person.prototype.getName = function(){
    // todo ...
};    

function Male(name, sex, age){
   //todo ...
}

//todo ...
Male.prototype.getAge = function(){
    //todo ...
};

var ruoyu = new Male('若愚', '男', 27);
ruoyu.getName();
function Person(name, sex){
    this.name = name
    this.sex = sex
}

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

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

Male.prototype = Object.create(Person.prototype)
Male.prototype.getAge = function(){
    alert(this.age)
};

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

推荐阅读更多精彩内容