继承

2017-06-27  本文已影响22人  RomainLiu

写完这篇文章,再也不用怕面试官问到继承了。

看看阮一峰大神的文章是怎么写的,他提到两种继承:

1、构造函数的继承

2、非构造函数的继承

下面是一个“动物“对象的构造函数

function Animal(){ this.species='动物'};

还有一个”猫“对象的构造函数

function Cat(name,color){
      this.name=name;
      this.color=color;
}

怎样让”猫“继承”动物“呢?

构造函数的继承

一、构造函数绑定(只继承私有属性)
function Cat(name,color){
      Animal.apply(this,arguments);
      this.name=name;
      this.color=color;
  }
var cat1=new Cat('小花','白色')
console.log(cat1.species);//动物
二、prototype模式(原型链继承)

如果”猫“的prototype对象,指向一个Animal的实例,那么所有”猫“的实例,就能继承Animal了。

Cat.prototype=new Animal();
Cat.prototype.constructor=Cat;
var cat1=new Cat('小花',‘白色’);
console.log(cat1.species);//动物

第一行代码,Cat的prototype对象指向了Animal的实例。

它相当于删除了prototype对象原先的值,然后赋予一个新的值。但是第二行又是什么意思呢?

原来,任何一个prototype对象都自带一个constructor的属性,指向它的构造函数。如果没有Cat.prototype=new Animal()这一行,Cat.prototype.constructor是指向Cat的,加了这一行后,Cat.prototype.constructor指向了Animal。

console.log(Car.prototype.constructor==Animal);//true

更重要的是,每一个实例也有一个constructor属性,它也会指向当前的这个类

console.log(Cat.prototype.constructor == Animal);//true;

因此,在运行Cat.prototype=new Animal();这一行之后,cat1.constructor也指向了Animal了,这显然造成了继承链的紊乱,所以必须把constructor指向改过来,即

Cat.prototype.constructor=Cat;
三、直接继承prototype

第三种方法是对第二种方法的改进。由于Animal队形中,不变的属性都可以直接写入Animal.prototype。所以,我们也可以让Cat()跳过Animal,直接继承Animal.prototype

现在我们将Animal对象改写:

function Animal(){    };
Animal.prototype.species='动物';

然后,将Cat的prototype对象,然后指向Animal的prototype对象,这样就完成了继承。

Cat.prototype=Animal.prototype;
Cat.prototype.constructor=Cat;
var cat1=new Cat('小花','yellow');
console.log(cat1.species);//动物

这种做法的好处是,效率比较高(不用执行和建立Animal的实例了),比较省内存。缺点是Cat.prototypeAnimal.prototype现在指向了同一个对象,那么任何对Cat.prototype的修改,都会反映到Animal.prototype

所以,上面的代码是有问题的,请看第二行

Cat.prototype.constructor=Cat;

相当于把Animal.prototype.constructor也改掉 了。

四、拷贝继承

这是用纯粹的“拷贝”来实现继承。简单说,如果把父对象的所有属性和方法,拷贝进子对象,不也能实现继承吗?

首先,还是把Animal的所有不变属性,都放到它的 prototype对象上。

function Animal(){ }
Animal.prototype.species='动物';

然后在写一个函数,实现拷贝的目的。

function extend(Child,Parent){
            var p=Parent.prototype;
            var c=Child.prototype;
            for (var i in p){
              c[i]=p[i];              
            }
}

使用的时候,这么写:

extend(Cat,Animal);
var cat1=new Cat('小花','白色');
console.log(cat1.species);//动物

非构造函数的继承

非构造函数继承,即不使用构造函数实现“继承”;

一、什么是“非构造函数”的继承?

比如,现在有一个对象,叫做“中国人”。

var Chinese = { nation : '中国' }

还有一个对象,叫做“医生”

var Doctor = {career : '医生'}

怎样才能让“医生”去继承“中国人”,也就是说,怎么得到“中国医生”这个对象?

二、Object.create()方法

它的意思是,把子对象的prototype属性,指向父对象,从而子对象与父对象连在了一起

实现原理

function create(o){
       function Fn(){};
       Fn.prototype=o;
       return new Fn();  
}

它是这么用的

var Doctor=Object.create(Parent);

然后,再加上对象本身的属性:

Doctor.career='医生';

这时,子对象已经继承了父对象的属性了。

console.log(Doctor.nation);//中国
三、浅拷贝

除了使用prototype链意外,还有另一种思路:把父对象的属性,全部拷贝给子对象,也能实现继承。

下面这个函数,实现了浅拷贝:

function shallowCopy(p){
        var c={};
        for(var i in  p){
            c[i]=p[i];
        }
       return c; 
}

使用的时候,这样写:

var Doctor=shallowCopy(Chinense);
Doctor.career='医生';
console.log(Doctor.nation); //中国

初学者可能认为这是一个深拷贝,但是有没有考虑过

Chinese.city=['北京','上海','广州'];

这种情况下,对于引用数据类型拷贝,拷贝的只是地址而已,不管在哪个对象里更改这个数据,另外一个也会跟着改。

深拷贝

所谓“深拷贝”,就是能够实现真正意义上的数组和对象的拷贝,它的拷贝并不难,只要递归调用就行了。

function deepClone(c,p){
    var c=c||{};
     for(var i in p){
       if(typeof p[i] ===  'object'){
        c[i] = c[i] instanceof Array?[]:{};
        deepClone(c[i],p[i]);  
    } else{
          c[i] = p[i];        
      }
      }
  }

使用方法:

var Doctort = deepClone(Chinese);

放上一张图,理解起来更直观。

类,实例,原型.png
上一篇 下一篇

猜你喜欢

热点阅读