js 继承

ECMAScript只支持落实持续(继承实际的点子),主要靠原型链来实现。

1、原型链

中心考虑是动原型为一个援类型继承另一个援类型的性能与方式。

示例:

  function SuperType(){
        this.property = true; //实例属性
    }
    SuperType.prototype.getSuperValue = function(){//原型方法
        return this.property;
    }

    function SubType(){
        this.subproperty = false;
    }
    
    //SubType继承了SuperType
    SubType.prototype = new SuperType();
    
    SubType.prototype.getSubValue = function(){
        return this.subproperty;
    }
    
    var instance = new SubType();
    console.log(instance.getSuperValue()); //true
    console.log(instance.constructor); //SuperType

说明:

  以上代码创建了点儿个类型:SuperType 和
SubType。这简单独品种且来独家的性能与方式,SubType继承了SuperType,继承是通过创设SuperType的实例,并将该实例赋给SubType的prototype。实现的原形是再次写了SubType原型对象,代的为一个初品类的实例。

  SubType的初原型具有SuperType所有的性和办法,同时其内部还有一个指南针[[Prototype]],指向SuperType的原型,最终结出是instance指向了SubType的原型,SubType的原型又针对了SuperType的原型。

  instance.constructor指向的是SuperType,这是为本来的SubType.prototype中的constructor被重新写了。(实际上不是SubType的原型的constructor属性被再度写了,而是SubType的原型指向了SuperType,而此原型的constructor属性指向的凡SuperType。)

  所有援类型默认都累了Object,这个连续也是由此原型链类实现之。所有函数的默认原型都是Object的实例,默认原型都见面蕴藏一个中指针,指向Object.prototype。

 

ECMAScript 1

留意:在经原型链实现持续时,不克使用字面量对象创建原型方法,这样会更写原型链,把我们的原型链切断。

原型链的问题:(1)、包含引用类型值的原型;

                   
(2)、创建子类型的实例时,不可知往超类型的构造函数中传送参数。

2、借用构造函数

也为伪造对象要藏延续,基本思维是以子类型构造函数内部调用超类型构造函数。

   function SuperType(name){
        this.name = name;
        this.colors = [‘red’, ‘blue’, ‘green’];
    }
    
    function SubType(){
        //继承了SubType,同时还传递了参数
        SuperType.call(this, ‘Nick’);
        
        //实例属性
        this.age = 12;
    }
    
    var instance1 = new SubType();
    instance1.colors.push(‘gray’);
    console.log(instance1.name);
    console.log(instance1.age);
    
    var instance2 = new SubType();
    console.log(instance2.colors);

假构造函数的题材:方法还于构造函数中定义,因此函数复用就未能谈起了。而且,在超类型的原型中定义之法,对子类型而言也是不可见的。

3、组合继承

为叫伪经典延续,基本考虑是采用原型链实现对原型属性和道的存续,通过借用构造函数实现对实例属性之接续,这样,即经过在原型上定义方法实现了函数复用,又能够确保每个实例都发它们和谐之性能。

   function SuperType(name){
        this.name = name;
        this.colors = [‘red’, ‘yellow’, ‘blue’];
    }
    
    SuperType.prototype.sayName = function(){
        return this.name;
    }
    
    function SubType(name, age){
        //继承属性
        SuperType.call(this, name);
        this.age = age;
    }
    //继承方法
    SubType.prototype = new SuperType();
    
    SubType.prototype.sayAge = function(){
        return this.age;
    }
    
    var instance1 = new SubType(‘Tom’, 12);
    instance1.colors.push(‘black’);
    console.log(instance1.colors);//[‘red’, ‘yellow’, ‘blue’,
‘black’]
    console.log(instance1.sayAge());//12
    console.log(instance1.sayName());//Tom
    
    var instance2 = new SubType(‘Lucy’,21);
    console.log(instance2.colors);//[‘red’, ‘yellow’, ‘blue’]
    console.log(SubType.prototype.isPrototypeOf(instance2));//true
    console.log(SuperType.prototype.isPrototypeOf(instance2));//true

结继承是JavaScript常因此之存续模式,但是呢发欠缺。

 4、寄生组合式继承

通过假构造函数来连续属性,通过原型链的混成形式来持续方法。

   
//借助原型基于已生目标创建新目标(本质上谈,object()对传播的靶子实行了千篇一律不良浅复制)
    function object(o){
        function F(){}
        F.prototype = o;
        return new F();
    }
    //使用寄生式继承来延续超类型的原型,然后再次将结果指定给子类型的原型
    function inheritPrototype(SuperType, SubType){
        var prototype =
object(SuperType.prototype);//创建超类型原型的一个副本
        prototype.constructor =
SubType;//增强对象,弥补因重写原型而错过的默认的constructor属性
        SubType.prototype = prototype;
    }

    function SuperType(name){
        this.name = name;
        this.colors = [‘blue’, ‘red’, ‘green’];
    }
    
    SuperType.prototype.sayName = function(){
        return this.name;
    }
    
    function SubType(name, age){
        SuperType.call(this, name);
        this.age = age;
    }
    
    inheritPrototype(SuperType, SubType);
    
    SubType.prototype.sayAge = function(){
        return this.age;
    }
    
    var instance = new SubType(‘Tom’, 12);
  instance.colors.push(‘black’);
  console.log(instance.colors);
  delete instance.name;
  console.log(instance.name);

  var instance = new SubType(‘Lucy’, 33);
  console.log(instance.colors);

普遍认为寄生组合式继承是援引类型最完美的连续范式。