码迷,mamicode.com
首页 > Web开发 > 详细

从头认识js-js中的继承

时间:2020-01-30 22:32:18      阅读:76      评论:0      收藏:0      [点我收藏+]

标签:const   理想   spro   开发人员   情况   super   效率   相同   prototype   

要彻底弄明白js中的继承,我们首先要弄清楚js中的一个很重要的概念那就是原型链。

1.什么是原型链?

我们知道每个构造函数都有一个原型对象,原型对象包含一个指向构造函数的指针,而实例都包含一个指向原型对象的内部指针。如果,让原型对象等于另一个引用类型的实例,那么原型对象中将包含一个指向另一个原型的指针,相应地,另一个原型对象中包含着一个指向另一个构造函数的指针。假如另一个原型对象又是另一个引用类型的实例,那么上述关系依然成立,如此层层递进,就构成了实例与原型之间的链条。这就是所谓原型链的基本概念。关键就是让原型等于另一个引用类型的实例。

2.默认原型

我们知道,所有引用类型默认都继承了Object,而这个继承也是通过原型链来完成的。记住:所有函数的默认原型都是Object的实例,因此默认原型都包含一个内部指针,指向Object.prototype.这也是所有自定义类型都会继承toString(),toValue()等方法的根本原因。

3.确定原型和实例之间的关系

1.使用instanceof操作符,只要用这个操作符来检测实例与原型链中出现过的构造函数,结果就会返回true

2.使用isPrototypeOf(),只要是原型链中出现过的原型,都可以说是原型链中所派生出来的实例的原型,结果就会返回true。

 4.谨慎地定义方法

子类型有时候需要覆盖超类中的某个方法,或者需要添加超类中不存在的某个方法。但不管怎样,给原型添加的方法一定要放在替换原型的语句之后,在通过原型实现继承时,不能使用对象字面量创建原型方法,因为这样做会重写原型,切断实例与原型之间的连接关系。

5.原型链的问题

引用类型值的原型属性会被实例共享;而这也是为什么要在构造函数中,而不是在原型对象中定义属性的原因。在通过原型实现继承的时候,原型实际上是变成另一个类型的实例,于是,原先的实例属性顺理成章地变成了现在的原型属性了。

下面代码可以说明这个问题:

function SuperType() {
    this.colors = [‘red‘, ‘orange‘, ‘green‘];
}
function SubType() { 
    
}
// 继承Supertype
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push(‘black‘);
console.log(instance1.colors); // [‘red‘,‘orange‘,‘green‘,‘black‘]
var instance2 = new SubType();
console.log(instance2.colors); // [‘red‘,‘orange‘,‘green‘,‘black’]

在这里我们把SubType的原型指向SuperType的一个实例,由于SuperType只实例了一次,所以实例instance1和instance2共享了colors属性,导致一变多变的现象出现,我们想的是每一个实例都有属于自己的一个属性副本,并不会进行相互的干扰。

此外,在创建子类型的实例的时候,我们无法向超类型的构造函数传递参数。

6.借用构造函数

这种技术的思想相当简单,即在子类型构造函数的内部调用超类型的构造函数,函数只不过是在特定环境中执行代码的对象,因此通过apply,call等方法也可以执行函数。

function SuperType() {
    this.colors = [‘red‘, ‘orange‘, ‘green‘];
}
function SubType() { 
    // 执行超类的构造函数,为子类的每个实例单独创建一个colors属性副本
    SuperType.call(this)
}
// 继承Supertype
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push(‘black‘);
console.log(instance1.colors); // [‘red‘,‘orange‘,‘green‘,‘black‘]
var instance2 = new SubType();
console.log(instance2.colors); // [‘red‘,‘orange‘,‘green‘]

如上面代码所示,我们在子类型的构造函数中执行了超类型的构造函数,这样子就为SubType的每一个实例单独创建了一个colors的属性副本,做到不相互干扰。

别忘了,apply个call函数除了执行函数之外,还可以传递参数,那么我们修改上面的例子,就可以实现向超类型的构造函数传递初始化参数。

代码如下:

function SuperType(name) {
    this.name = name
}
function SubType(name) { 
    // 执行超类的构造函数,为子类的每个实例单独创建一个colors属性副本
    SuperType.call(this,name);
    this.colors = [‘red‘];
}
// 继承Supertype
SubType.prototype = new SuperType();
var instance1 = new SubType(‘instance1‘);
instance1.colors.push(‘black‘);
console.log(instance1.name);// instance1
console.log(instance1.colors); // [‘red‘]
var instance2 = new SubType(‘instance2‘);
console.log(instance2.colors); // [‘red‘]
console.log(instance2.name);// instance2

借用构造函数模式的问题,方法都在构造函数中定义,因此函数复用就无从谈起了,而且在超类型的原型中定义的方法,对子类型是不可见的,结果所有类型只能使用构造函数模式。

7.组合继承

 组合继承,有时候叫做伪经典继承,指的是将原型链和借用构造函数的技术组合在一起的一种继承模式。其背后的思路是使用原型链实现对原型属性和方法的继承,而通过借用构造函数实现对实例属性的继承。

看如下代码:

 

function SuperType(name) {
    this.name = name;
    this.colors = [‘red‘,‘orange‘,‘green‘];
}
SuperType.prototype.sayName = function() {
    console.log(this.name);
}
function SubType(name,age) { 
    // 执行超类的构造函数,为子类的每个实例单独创建一个colors属性副本
    SuperType.call(this,name);
    this.age = age;
}
// 继承Supertype
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function() {
    console.log(this.age);
}
var instance1 = new SubType(‘instance1‘,22);
instance1.colors.push(‘black‘);
instance1.sayName();// instance1
instance1.sayAge();// 22
console.log(instance1.colors); // [‘red‘,‘orange‘,‘green‘,‘black‘]
var instance2 = new SubType(‘instance2‘,23);
console.log(instance2.colors); // [‘red‘,‘orange‘,‘green‘]
instance2.sayName();// instance2
instance2.sayAge();// 23

 

这样一来,就可以让两个不同的SubType实例既分别拥有自己属性--包括colors属性,又可以使用相同的方法了。

组合继承避免了原型链和构造函数的缺陷,融合了它们的优点,成为JavaScript中最常用的继承模式。而且instanceof和isPrototypeOf()也能够用于识别基于组合继承创建的对象。

 8.原型式继承

借助原型可以基于已有的对象创建新对象,同时还不必因此创建自定义类型。

代码如下:

function object(o) {
    function F() { }
    F.prototype = o;
    return new F();
}

这种方式必须有一个对象可以作为另一个对象原型的基础,如果有这么一个对象,就可以传递给object函数,然后在根据具体需求对得到的对象加以修改即可。

ECMAScript5中新增了Object.create()方法规范了原型式继承。接受两个参数:

1.一个用做新对象原型的对象([[prototype]]__proto__可选)

2.第二个参数是一个用作新对象自定义属性的对象(同名属性会覆盖原型对象上的同名属性)。

在没有必要创建构造函数的时候,而只想让一个对象与另一个对象保持类似的情况下,原型式继承是完全可以胜任的。但是,包含引用类型值的属性始终都会共享相应的值。

9.寄生式继承

创建一个仅用于封装继承过程的函数,该函数在内部以某种方式来增强对象,最后再像真地是它做了所有工作一样返回对象。如下代码所示:

function object(o) {
    function F() { }
    F.prototype = o;
    return new F();
}
function createAnother(original) {
    var cloen = object(original);
    cloen.sayHi = function () {
        console.log(‘hi‘);
    }
    return cloen;
}

在主要考虑对象而不是自定义类型和构造函数的情况下,寄生式继承也是一种有用的模式。使用寄生式继承来为对象添加函数,会由于不能做到函数复用而降低效率;这一点于构造函数模式类似。

10.寄生组合式继承

前面说到的组合继承也有自己的不足,就是会调用两次超类型的构造函数,这样子就给子类型构造函数的原型对象上添加了额外的属性和方法。

代码如下:

function SuperType(name) {
    this.name = name;
    this.colors = [‘red‘, ‘orange‘, ‘green‘];
}
SuperType.prototype.sayName = function () {
    console.log(this.name);
}
function SubType(name, age) {
    // 执行超类的构造函数,为子类的每个实例单独创建一个colors属性副本
    SuperType.call(this, name); //第二次调用
    this.age = age;
}
// 继承Supertype
SubType.prototype = new SuperType(); // 第一次调用
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function () {
    console.log(this.age);
}
var instance1 = new SubType(‘instance1‘, 22);
instance1.colors.push(‘black‘);
instance1.sayName();// instance1
instance1.sayAge();// 22
console.log(instance1.colors); // [‘red‘,‘orange‘,‘green‘,‘black‘]
var instance2 = new SubType(‘instance2‘, 23);
console.log(instance2.colors); // [‘red‘,‘orange‘,‘green‘]
instance2.sayName();// instance2
instance2.sayAge();// 23

使用寄生组合继承可以这样子写:

function object(o) {
    function F() { }
    F.prototype = o;
    return new F();
}
function inheritPrototype(subType,superType) {
    // 返回一个新对象
    var prototype = object(superType.prototype);
    // 原型中constructor的指向
    prototype.constructor = subType;
    // 重写原型
    subType.prototype = prototype;
}

这样子就可以替换为子类原型赋值的语句了,如下代码:

function SuperType(name) {
    this.name = name;
    this.colors = [‘red‘, ‘orange‘, ‘green‘];
}
SuperType.prototype.sayName = function () {
    console.log(this.name);
}
function SubType(name, age) {
    // 执行超类的构造函数,为子类的每个实例单独创建一个colors属性副本
    SuperType.call(this, name); 
    this.age = age;
}
// 继承Supertype
inheritPrototype(SubType,SuperType);
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function () {
    console.log(this.age);
}
var instance1 = new SubType(‘instance1‘, 22);
instance1.colors.push(‘black‘);
instance1.sayName();// instance1
instance1.sayAge();// 22
console.log(instance1.colors); // [‘red‘,‘orange‘,‘green‘,‘black‘]
var instance2 = new SubType(‘instance2‘, 23);
console.log(instance2.colors); // [‘red‘,‘orange‘,‘green‘]
instance2.sayName();// instance2
instance2.sayAge();// 23

function object(o) {
    function F() { }
    F.prototype = o;
    return new F();
}
function inheritPrototype(subType,superType) {
    // 返回一个新对象
    var prototype = object(superType.prototype);
    // 原型中constructor的指向
    prototype.constructor = subType;
    // 重写原型
    subType.prototype = prototype;
}

这样子一来,我们就省略了给子类型原型赋值的操作,避免了给子类原型上面添加了额外的属性。开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。

从头认识js-js中的继承

标签:const   理想   spro   开发人员   情况   super   效率   相同   prototype   

原文地址:https://www.cnblogs.com/jsydb/p/12240552.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!