JavaScript-浅谈继承

作为面向对象语言大军中的一员,javascript的继承问题也会经常出现在前端面试中,很多小伙伴都折在这个问题上,今天为各位小伙伴们整理了js中的6种继承,并指出它们各自最核心的特点,可作为前端面试准备资料。

一、原型链继承

1、核心:

将父类的实例作为子类的原型。

2、代码:

        function Father1(){
            this.name = 'baba';
        }
        Father1.prototype.getName = function(){
            return this.name;
        }
        function Son1(){
            this.sonname = 'erzi';
        }
        Son1.prototype = new Father1();         //核心步骤
        Son1.prototype.getSonName = function(){
            return this.sonname;
        }
        var son1 = new Son1();
        console.log(son1.getName());       //输出为baba    son1继承了父类中的getName方法
        console.log(son1.getSonName());    //输出为erzi   son1继承了父类之后又新添加的方法
        console.log(son1 instanceof Father1);   //输出为true    son1也是父类的实例

3、缺点:

a、所有新实例都会共享父类实例的属性;
b、新实例无法向父类构造函数传递参数;
c、继承单一。

二、借用构造函数继承

1、核心:

用.call()或者.apply()将父类的构造函数引入子类函数中。

2、代码:

        function Father2(name){
            this.name = name;
        }
        function Son2(){
            Father2.call(this,'xiaoming');    //核心步骤,继承了父类,同时传递了参数。相对原型链继承一个很大的优势。
            this.age = 20;
        }
        var son2 = new Son2();
        console.log(son2.name);
        console.log(son2.age);
        console.log(son2 instanceof Father2);    //输出为false    son不是父类的实例

3、缺点:

a、只能继承父类构造函数中的属性,不能继承父类原型的属性;
b、无法实现构造函数的复用(每次用都要重新调用);
c、每个新实例都会有父类构造函数的副本,臃肿,影响性能;
d、实例并不是父类的原型,只是子类的实例。

三、组合继承

1、核心:

组合原型链继承和借用构造函数继承

2、代码:

        function Father3(name){
            this.name = name;
        }
        Father3.prototype.sayName = function(){
            console.log(this.name);
        }
        function Son3(name,age){
            Father3.call(this,name);      //借用构造函数继承,可以传参。  继承父类属性   第二次调用父类构造函数
            this.age = age;
        }
        Son3.prototype = new Father3();   //原型链继承  继承父类原型对象上的方法   第一次调用父类构造函数
        Son3.prototype.sayAge = function(){
            console.log(this.age);
        }
        var son3 = new Son3('zhangsan',18);
        console.log(son3.name);
        son3.sayName();
        son3.sayAge();
        console.log(son3 instanceof Father3)   //输出为true    son3也是父类的实例

3、特点:

避免了两种模式的缺陷,结合了两种模式的优点:传参和复用,最常用的继承模式。

4、缺点:(重要)

调用两次父类构造函数,一次是在创建子类原型的时候,一次是在子类构造函数内部。耗内存。

四、原型式继承

1、核心:

基于已有的对象创建新对象.

2、代码:

        function Father4(name){
            this.name = name;
            this.age = 10;
        }
        function object(o){
            function F(){}
            F.prototype = o;  //继承了传入的参数
            return new F();  //返回了函数对象
        }
        var sup = new Father4();   //父类的一个实例
        var sup1 = object(sup);   //将这个实例传入到object函数中
        console.log(sup1.age);    //输出为10  sup1继承了父类的属性

3、特点:

a、类似于复制一个对象,用函数来包装;
b、所有新实例都会继承原型上的属性,无法复用。
[object函数:先创建了一个临时的构造函数,然后把传入的对象作为这个构造函数的原型,最后返回这个临时类型的新实例.]

五、寄生式继承

1、核心:

创建一个仅用来封装过程的函数,该函数在内部以某种形式来增强对象,最后再返回对象。

2、代码:

        function Father5(name){
            this.name = name;
            this.age = 20;
        }
        function object(o){
            function F(){}
            F.prototype = o;  //继承了传入的参数
            return new F();  //返回了函数对象
        }
        //相当于给原型式继承套了一个壳子
        function createSon(obj){
            var created = object(obj);
            //在内部可以增强对象,添加新的方法和属性
            created.sayHi = function(){
                console.log("hi");
            }
            return created;
        }
        var father5 = new Father5('bababa');
        var son5 = createSon(father5);
        console.log(son5.age);    //20
        son5.sayHi();             //hi

3、缺点:

没用到原型。

六、组合式寄生式继承

1、核心:

不必为了指定子类型而调用父类型的构造函数,我们只需要父类型圆形的一个副本。

2、代码:
        function object(o){
            function F(){}
            F.prototype = o;  //继承了传入的参数
            return new F();  //返回了函数对象
        }
        function Fn(father,son){
            var proto = object(father.prototype);  //创建对象 创建父类型原型的副本
            proto.constructor = son;               //增强对象 为创建的副本添加constructor属性
            son.prototype = proto;                 //指定对象 将创建的副本赋值给子类型的原型
        }
        function Father6(name){
            this.name= name;
        }
        Father6.prototype.sayName = function(){
            console.log(this.name);
        }
        function Son6(name,age){
            Father6.call(this,name);
            this.age = age;
        }
        Fn(Father6,Son6);                          //核心
        var son6 = new Son6('daerzi',16);
        son6.sayName();                       //输出为daerzi
        console.log(son6 instanceof Father6)  //输出为true

3、特点:

解决了组合式继承的缺点。(忘了组合式继承什么缺点了?翻回去再看一遍吧~)

【作者水平有限,欢迎大家在评论区交流指正~】

你可能感兴趣的