精华内容
下载资源
问答
  • 2021-07-10 17:05:37

    寄生继承

    寄生继承相当于对原型继承的二次封装,并在二次继承中对继承的对象进行拓展,使其不仅拥有父类的属性方法也拥有新加的属性方法。

    function Person(name, age) {
            this.name = name;
            this.age = age;
        }
        Person.prototype = {
            sleep: function () {
                console.log(this.name + "在睡觉!");
            }
        }
    
        //实例继承
        function Student(obj) {
            function fun() {
    
            }
            //寄生到  fun函数的prototype上面
            fun.prototype = obj;
            return new fun();
        }
    
        var p = new Person('小明',18);//实例化person
    
        //带个壳子
        function getObj() {
            var stu=Student(p);
            stu.work="学习";
            return stu;
        }
    
        var s = getObj();
    
        console.log(s);
        s.sleep();
    

    用寄生式继承来为对象添加函数,会由于不能做到函数复用而降低效率

    更多相关内容
  • 组合继承(通过改变this指向进行继承) 组合继承也被称为伪经典继承,它综合了我们昨天说的原型链和盗用构造函数,将两者的优点结合在了一起。它的基本思想是使用原型链继承原型上的属性和方法,通过盗用构造函数...

    在这里插入图片描述

    组合继承(通过改变this指向进行继承)

    组合继承也被称为伪经典继承,它综合了我们昨天说的原型链和盗用构造函数,将两者的优点结合在了一起。它的基本思想是使用原型链继承原型上的属性和方法,通过盗用构造函数继承实例属性,这样的好处就是可以把方法定义在原型上复用,每个实例又有自己的属性。

        // 先声明一个构造函数 SuperType ,并且给它定义属性
        function SuperType (name) {
            this.name = name;
            this.colors = ["red","yellow","bule"];
        }
        // 给构造函数的原型对象上添加方法 sayName
        SuperType.prototype.sayName = function(){
            console.log(this.name)
        }
        // 声明一个构造函数 SubType
        function SubType(name,age){
            // 通过 call 方法修改 this 指向,这样SubType 这个构造函数就可以访问到构造函数 SuperType 里面的属性以及原型对象上的属性和方法
            SuperType.call(this,name);
            this.age = age;
        }
        // 把刚开始定义的那个构造函数 SuperType 的实例对象赋值称为构造函数 SubType 的原型对象
        SubType.prototype = new SuperType();
        // 给构造函数 SubType 的原型对象添加 sayAge 方法
        SubType.prototype.sayAge = function(){
            console.log(this.age);
        }
        // 实例化 SubType
        let instancel = new SubType("jackson",22);
        //就可以访问自身以及继承下来的属性和方法
        instancel.colors.push("pink");
        instancel.sayName(); // "jackson"
        instancel.sayAge();//22
        console.log(instancel.colors);// ["red", "yellow", "bule", "pink"]
        
        let instance2 = new SubType("bear", 20);
        console.log(instance2.colors); // ["red", "yellow", "bule"]
        instance2.sayName(); // "bear";
        instance2.sayAge(); // 20
    

    组合继承弥补了原型链和盗用构造函数的不足,是js中使用最多的继承模式。

    寄生式继承

    寄生式继承就是用一个函数包装一个对象,然后返回这个函数的调用,这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。

     // 寄生式继承
        function subobject(obj) {
            let clone = Object(obj);
            clone.sayName = function(){
                console.log("jackson")
            };
            return clone;
        }
        let sub = {
            name:"bear"
        }
        let sup = subobject(sub);
        sup.sayName();//jackson
    

    寄生式继承同样适合主要关注对象,而不在乎类型和构造函数的场景。object()函数不是寄生式继承所必需的,任何返回新对象的函数都可以在这里使用。

    寄生式组合继承

    组合继承存在这一定的效率问题,它的父类构造函数始终会被调用俩次,一次在创建字类原型时调用,另一次在子类构造函数中调用。本质上子类只需要在执行时重写自己的原型就行了。

        function inheritPrototype(subType, superType) {
            let prototype = Object(superType.prototype); // 创建对象
            prototype.constructor = subType; // 增强对象
            subType.prototype = prototype; // 赋值对象
        }
    

    这个 inheritPrototype()函数实现了寄生式组合继承的核心逻辑。这个函数接收两个参数:子类构造函数和父类构造函数。在这个函数内部,第一步是创建父类原型的一个副本。然后,给返回的 prototype 对象设置 constructor 属性,解决由于重写原型导致默认 constructor 丢失的问题。最后将新创建的对象赋值给子类型的原型。如下例所示,调用 inheritPrototype()就可以实现前面例子中的子类型原型赋值:

       // 先声明一个构造函数 SuperType ,并且给它定义属性
        function SuperType (name) {
            this.name = name;
            this.colors = ["red","yellow","bule"];
        }
        // 给构造函数的原型对象上添加方法 sayName
        SuperType.prototype.sayName = function(){
            console.log(this.name)
        }
        // 声明一个构造函数 SubType
        function SubType(name,age){
            // 通过 call 方法修改 this 指向,这样SubType 这个构造函数就可以访问到构造函数 SuperType 里面的属性以及原型对象上的属性和方法
            SuperType.call(this,name);
            this.age = age;
        }
        inheritPrototype(SubType, SuperType);
        SubType.prototype.sayAge = function () {
            console.log(this.age);
        };
    

    这里只调用了一次 SuperType 构造函数,避免了 SubType.prototype 上不必要也用不到的属性, 因此可以说这个例子的效率更高。而且原型链仍然保持不变。

    寄生式组合继承可以算是引用类型继承的最佳模式。

    在这里插入图片描述

    展开全文
  • 下面小编就为大家带来一篇浅谈JS继承_寄生继承 & 寄生组合式继承。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • JS寄生组合继承

    2022-02-27 11:11:57
    寄生组合继承 就是 组合继承 + 原型继承 的结合体 js内部会把这个寄生组成封装成 extend function Father(name) { this.name = name this.hbody = ['吃饭', '睡觉', '打豆豆'] } Father.prototype.getName = ...

    寄生组合继承 就是 组合继承 + 原型继承 的结合体 js内部会把这个寄生组成封装成 extend

    function Father(name) {
        this.name = name
        this.hbody = ['吃饭', '睡觉', '打豆豆']
    }
    Father.prototype.getName = function() {
        console.log(this.name)
    }
    function Son(name, age) {
        Father.call(this, name)
        this.age = age
    }
    Son.prototype = Object.create(Father.prototype)
    Son.prototype.construtor = Son
    let S = new Son('亚瑟', '22')
    let F = new Father('李白')
    console.log('寄生组合1', S)
    console.log('寄生组合2', F)
    

    在这里插入图片描述

    展开全文
  • 主要介绍了JavaScript继承基础讲解,原型链、借用构造函数、混合模式、原型式继承寄生继承寄生组合式继承,需要的朋友可以参考下
  • JS-寄生组合式继承

    2021-12-25 12:26:29
    js继承组合式继承-es6之前最佳继承方式

    原型继承

    child.prototype=new Parent()
    function A(x){
    	this.x=x
    }
    A.prototype.getX=function(){console.log(this.x)}
    function B(y){
    	this.y=y
    }
    B.prototype.gety=function(){console.log(this.y)}
    B.prototype=new A()
    B.prototype.constructor=B//由于B的原型对象指向A的实例了,那么其构造器就会指向A,因此要改一下原型对象中构造器的指向
    

    让子类的原型指向父类的实例,父类的实例的原型链会指向类的原型.这个方式有很大的缺点:当修改子类实例父类实例也会发生变化,因为这里是使用引用的方式,即在同一个内存空间里操作
    在这里插入图片描述

    Object.create()

    创建一个新对象,使用现有的对象来提供新创建的对象的__proto__
    即给你的对象提供一个__proto__

    继承组合式继承方式

    是用call继承和Object.create

            function Person(name){
                this.name=name
            }
            function A(sex){
                Person.call(this,'A extends Person')
                this.sex=sex
            }
            Person.prototype.getName=function(){
                console.log(this.name)
            }
            A.prototype=Object.create(Person.prototype)
            A.prototype.constructor=A
    

    call继承的目的在于将Person的私有属性继承为自己的私有属性,接下来的每个A的实例都会有一个私有属性name=’A extends Person‘,但只用call继承还不够,我们在这里将父构造函数当普通方法调用了,但无法拿到父类原型对象上的属性和方法。因此我们需要将子类原型指向父类的原型。这样给A的prototype原型对象提供了Person.prototype,这样A的实例的__proto__指向A的prototype,A的prototype的__proto__指向Person的prototype。这种组合式继承即拿到了父类的私有属性和方法成为自己的私有属性方法,也拿到了父类公有的属性和方法。是在es6继承之前的最佳方式

    图里的A就是Person父类
    在这里插入图片描述

    展开全文
  • 文章目录前言一、什么是寄生继承?二、使用实例三、总结 前言 写本《JavaScript简餐》系列文章的目的是记录在阅读学习《JavaScript高级程序设计(第4版)》一书时出现的各个知识点。虽是对读书的笔记和总结,但是...
  • 文章目录前言一、什么是寄生组合继承?二、寄生组合继承的基本模式三、总结 前言 写本《JavaScript简餐》系列文章的目的是记录在阅读学习《JavaScript高级程序设计(第4版)》一书时出现的各个知识点。虽是对读书的...
  • js组合继承和组合寄生继承 js设计之初是没有继承的概念的,如果要实现ES6中class A extends B的形式,需要借用prototype和Function.prototype.apply()方法或Function.prototype.call()方法。 原型链继承方式:B....
  • 一、原型式继承本质其实就是个浅拷贝,以一个对象为模板复制出新的对象 1 2 3 4 5 6 7 8 9 10 11 12 13 14 function object( o ){ var G ...
  • 寄生继承是与原型式继承紧密相关的一种思路。寄生继承的思路与寄生构造函数和工程模式类似,即创建一个仅用于封装继承过程的函数,该函数的内部以某种方式来增强对象,最后再像真的是它做了所有工作一样返回对象...
  • 继承本质上就是一个对象复用另一个对象的属性和方法,注意,属性和方法的复用效果是不同的,从这点出发去理解继承,也就能理解为什么会产生六种继承
  • 原型式继承 原理等同ES5的Object.create()方法, 创建一个函数,使这个函数成为括号中obj的构造函数,也就是这个函数的原型指向这个obj 然后返回这个构造函数的实例,是一个浅拷贝,新实例的引用数据类型改变会让...
  • js继承寄生组合继承 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" ...
  • 目录一、回顾 组合继承 (伪经典继承)二、寄生式组合继承 一、回顾 组合继承 (伪经典继承) 结合了构造函数继承+对象原型继承 不足的地方是:每个实例对象 都执行了两次Super函数,一次是prototype赋值,一次...
  • JS继承之寄生继承

    千次阅读 2018-09-05 16:58:57
    JavaScript继承还有一种继承模式——寄生继承。 举个例子: function object(o) { function F() {}; F.prototype = o; return new F(); } var twoD = { name: '2D shape', dimensions: 2 } function triangle...
  • js代码-寄生组合继承方式
  • 什么是寄生继承 寄生继承的思路与寄生构造函数和工厂模式类似,即创建一个仅用于封装继承过程的函数,该函数在内部以某种方式来增强对象,后再像真的是它做了所有工作一样返回对象。 例如: function ...
  • 主要介绍了JavaScript寄生组合式继承,结合实例形式详细分析了寄生组合式继承原理、实现方法与相关注意事项,需要的朋友可以参考下
  • 主要介绍了JavaScript寄生组合式继承,结合实例形式分析了javascript寄生组合式继承的原理、定义与简单使用方法,需要的朋友可以参考下
  • JS 寄生 继承

    2017-02-20 12:23:00
    寄生构造函数 寄生构造函数的用途目的:给String内置对象功能扩充 稳妥的构造函数 ...继承 ...对象冒充继承 ...一般继承 ...组合继承 ...原型链继承:借助于中转...寄生组合继承,借助于中转函数和寄生函数组合继承:原型链 ...
  • 下面小编就为大家带来一篇[js高手之路]原型式继承寄生继承详解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • JS基础--组合继承寄生组合式继承

    千次阅读 2019-05-13 17:03:29
    以下内容总结自《JavaScript高级程序设计(第3版)》 一. 组合继承 组合继承使用原型链实现对原型属性和方法的继承,使用借用构造函数实现对实例属性的继承(引用类型的属性写在构造函数里)。 示例: function ...
  • 回顾一下JavaScript想实现继承的目的:重复利用另外一个对象的属性和方法. 最终的目的:student对象的原型指向了person对象; 二、寄生继承函数 寄生式(Parasitic)继承是与原型式继承紧密相关的一种思想, 并且...
  • 在之前javascript面向对象系列的文章里面,我们已经探讨了组合继承和寄生继承,回顾下组合继承: function Person( uName ){ this.skills = [ 'php', 'javascript' ]; this.userName = uName; } Person....
  • 以下为JS寄生组合继承的实现方式 ``` function Super(b){ this.b = b; this.fun = function(){} } Super.prototype.c = function(){console.log(1111)} function Foo(a,b){ this.a = a; Super....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,980
精华内容 3,192
关键字:

js寄生继承