js继承的六种方式详解--认真看完你就会了

JavaScript寄生组合式继承实例详解 本文实例讲述了JavaScript寄生组合式继承。分享给大家供大家参考,具体如下: 其实《JavaScript高级程序设计》这本书中已经有完整代码了,只要把代码读懂就知道这个继承是怎么回事。 首先,在js中,给对象定义属性有两种方式: //通过执行构造函数设置属性 function A(){ this.a = 1; } //通过原型设置属性 A.prototype.b = 1; 所以: 一个类Sub要继承另一个类Super,需要继承父类的prototype下的属性,还要执行一下父类的构造函数。 即一个类Sub要继承另一个类Super,既要通过原型链实现对原型属性和方法的继承,又要通过在子 立即下载

今天 主要来研究一下继承这个东西

继承

共分为六种继承方式:

  • 原型链继承
  • 盗用构造函数继承
  • 组合继承
  • 实例继承(原型式继承)
  • 寄生式继承
  • 寄生式组合继承

 原型链继承

原型链继承是ES主要继承方法,其中基本思想就是 通过原型链继承多个引用类型的属性和方法

那么构造函数、原型、实例之间的关系是什么呢?

答:每个构造函数都有一个原型对象,原型有一个属性指回构造函数,而实例有一个内部指针指向原型,如果原型是另一个类型的实例呢?那就意味着这个原型本身有一个内部指针指向另一个原型,相应地另一个原型也有一个指针指向另一个构造函数。。。这样就在实例与原型之间构造了一条原型链,,,这就是原型链的基本构想。

下面举例说明原型链模式~

    function parent(){
        this.flag = true //该方法定义一个属性
    }
    parent.prototype.getParentValue = function(){
        return this.flag
    }
    console.log(parent.prototype)
 
    function child(){
        this.flag1 = false
    } //创建一个构造函数child

    child.prototype = new parent() //让child通过创建实例,继承parent
    console.log(child.prototype) //child的原型就是parent函数

    child.prototype.getChildValue = function(){
        return this.flag1
    }
    let instance = new child()
    console.log(instance.getParentValue()) //true

以上三处打印值分别如下:

将以上的结果对应图再看一下:

总的思想就是:

我们在读取实例上的属性时,首先会在这个实例上搜索到这个属性,如果没找到,则会继承搜索实例的原型 ,在通过原型链实现继承之后,会继续搜索原型的原型。就例子而言,调用instace.getParentValuve()去寻找父节点的函数值的时候,经过了3步搜索,先搜索instace、接着是child.prototype,然后是parent.prototype,最后一步才找到该方法。。。那么对于属性和方法的搜索会一直持续到原型链的末端。

原型链继承的问题

抛出问题1:原型中包含的引用值会在所有实例间共享,这也是为什么属性通常会在构造函数中定义而不会在原型上定义的原因---重点

用例子来阐述问题

    // 继承的问题
    function parent(){
        this.colors = ['red','blue','white']
    }
    function child(){}

    child.prototype = new parent() 
    let instance1 = new child()
    instance1.colors.push('black')
    console.log(instance1.colors) //["red", "blue", "white", "black"]

    let instance2 = new child()
    console.log(instance2.colors) //["red", "blue", "white", "black"]

看到了吗,解读一下:这个例子中,parent构造函数定义了一个colors属性,其中包好一个数组(引用值),然后每个parent的实例都会有自己的colors属性,并包含着自己的数组,但当child通过原型继承了parent之后,child原型变成了parent的一个实例,因此也获得了自己的colors属性,最终结果就是child所有实例都会共享这个属性,因此instance1的修改会影响instance2的修改

抛出问题2:原型链的第二个问题是子类型在实例化时不能给父类型的构造函数传参,因此原型链方法一般不会单独使用

盗用构造函数继承

构造函数继承是为了解决原型包含引用值会共享而出现的,它的基本思路是:在子类构造函数中调用父类构造函数,可以使用apply()和call()方法(关于apply()和call()方法的使用 可以查看 https://blog.csdn.net/qq_41579104/article/details/108489259) 以新创建的对象为上下文执行构造函数

举个栗子吧~

    // 构造函数继承
    function parent(){
        this.colors = ['red','blue','white']
    }
    function child(){
        parent.call(this) //继承parent
    }
    let instance1 = new child()
    instance1.colors.push('black')
    console.log(instance1.colors) //["red", "blue", "white", "black"]

    let instance2 = new child()
    console.log(instance2.colors) //["red", "blue", "white"]

例子中,通过使用call()或apply()方法,parent构造函数在为child的实例创建的新对象的上下文中执行了,这就相当于新的child对象上运行了parent函数中所有初始化代码 ,结果就是每个实例都会有自己的colors属性

还有一个优点,就是可以在子类构造函数中向父类构造函数传参了,解决了原型链的缺点。

    // 传参
    function parent(name){
        this.name = name
    }
    function child(){
        parent.call(this,'hengheng')//继承parent并传参
        this.age = 20 //实例属性
    }
    let instance = new child()
    console.log(instance.name)
    console.log(instance.age)

例子解读:这个例子中,parent构造函数接收一个参数那么,然后他赋值给一个属性,在child构造函数中调用parent时传入这个参数,实际上会在child的实例上定义那么属性。

构造函数继承的问题

抛出问题:主要缺点就是必须在构造函数中定义方法,因此函数不能复用,也就是说子类不能访问父类原型上定义的方法,因此所有类型只能使用构造函数模式,因此他也不可以单独使用

组合继承(组合原型链继承和盗用构造函数继承)

组合继承呢,综合了原型链和构造函数,将两者的优点集中了起来,基本思路是:使用原型链继承原型上的属性和方法,通过构造函数继承实例属性,这样既可以把方法定义在原型上实现复用,又可以让每个实例都有自己的属性

一个例子说明一切:

    // 组合继承
    function parent(name){
        this.name = name
        this.colors = ["red", "blue", "white"]
    }
    parent.prototype.sayName = function(){
        console.log(this.name)
    }
    function child(name,age){
        // 继承属性
        parent.call(this,name)
        this.age = age                                                       
    }
    //继承方法
    child.prototype = new parent()
    child.prototype.sayAge = function(){
        console.log(this.age)
    }
    let instance1 = new child('hengheng',20)
    instance1.colors.push("black")
    console.log(instance1)
    instance1.sayAge()
    instance1.sayName()

    let instance2 = new child('suosuo',22)
    instance2.colors.push("yellow")
    console.log(instance2)
    instance2.sayAge()
    instance2.sayName()

例子解读:

在这个例子中,parent构造函数定义了两个属性,name和colors,而他的原型上也定义了一个方法是sayname,child构造函数调用了parent构造函数(构造函数继承),传入了name参数,然后又定义了自己的属性age,此外child.prototype也被赋值为parent的实例,原型赋值后,又在这个原型上添加了新方法sayage,这样,就创建了两个child实例,让这两个实例都有自己的属性,包括colors,同时还共享相同的方法,完美的弥补了原型链和构造函数继承的不足。

重点:结合了两种模式的优点,传参和复用

特点:1、可以继承父类原型上的属性,可以传参,可复用。
   2、每个新实例引入的构造函数属性是私有的。

缺点:调用了两次父类构造函数(耗内存),子类的构造函数会代替原型上的那个父类构造函数。

原型式继承

这个方式主要是介绍了一种不涉及严格意义上构造函数的继承方法,它的出发点是即使不自定义类型也可以通过原型实现对象之间的信息共享

    // 原型式继承
    function object(o){
        function F(){}  //这个object()函数会创建一个临时构造函数
        F.prototype = o //将传入的对象赋值给这个构造函数的原型,
        return new F()  //然后返回这个临时类型的一个实例,object()是对传入的对象执行了一次浅复制
    }
    
    let person = {
        name:"hengheng",
        friends:[
            "xiaobai",
            "xiaohuang",
            "xiaoli"
        ]
    }
    let otherPerson = object(person)
    otherPerson.name = "suosuo";
    otherPerson.friends.push("xiaozhang")

    let anotherPerson = object(person)
    anotherPerson.name = "linda";
    anotherPerson.friends.push("xiaowang")

    console.log(person.friends)//["xiaobai", "xiaohuang", "xiaoli", "xiaozhang", "xiaowang"]
    console.log(otherPerson)
    console.log(anotherPerson)

原型式继承适用于:你有一个对象,想在它的基础上再创建一个新对象,你需要先把这个对象传给object,然后再对返回的对象进行操作。

例子解读:

这个例子中,person对象定义了另一个对象也应该共享的信息,然后把它传给object()之后会返回一个新对象,这个新对象的原型是person,意味着它的原型上既有原始属性又有引用值属性,这也意味着person.friends不仅是person的属性,也会跟着otherPerson和anotherPerson共享,这里实际上克隆了两个person。

那么在ES5中新增的create()方法将原型式继承的概念规范化了,这个方法接收两个参数:作为新对象原型的对象,以及给新对象定义额外属性的对象(第二个可选),在只有一个参数时,Object.create()与这里的objec的作用相同。

举个栗子(Object.create()只有一个参数时):

    let person = {
        name:"hengheng",
        friends:[
            "xiaobai",
            "xiaohuang",
            "xiaoli"
        ]
    }
    let anotherPerson = Object.create(person)
    anotherPerson.name = "suosuo"
    anotherPerson.friends.push("xiaowang")

    let otherPerson = Object.create(person)
    otherPerson.name = "hengheng"
    otherPerson.friends.push("xiaozhang")

    console.log(person.friends)

举个栗子(Object.create()有两个参数时):

    let person = {
        name:"hengheng",
        friends:[
            "xiaobai",
            "xiaohuang",
            "xiaoli"
        ]
    }

    let anotherPerson = Object.create(person,{
        name:{
            value:"suosuo"
        }
    })
    console.log(anotherPerson.name)//suosuo

 Object.create()的第二个参数作用:以这种方式添加的属性会遮蔽原型对象上的同名属性。

原型链继承的问题:类似于复制一个对象,用函数来包装(特点),它非常适合不需要创建构造函数,但仍需要在对象间共享信息的场合(优点),但是,属性中包含的引用值始终会在相关对象间共享,跟使用原型模式一样,无法实现复用(缺点)。

寄生式继承

该继承方式与原型式继承比较接近,它的思路类似于寄生构造函数和工厂模式:创建一个实现继承的函数,以某种方式增强对象,然后返回这个对象

    // 寄生式继承
    function object(o){
        function F(){}  //这个object()函数会创建一个临时构造函数
        F.prototype = o //将传入的对象赋值给这个构造函数的原型,
        return new F()  //然后返回这个临时类型的一个实例,object()是对传入的对象执行了一次浅复制
    }
    function createAnother(o){
        let clone = object(o) //通过调用函数创建一个新对象
        clone.sayHi = function(){ //以某种方式增强对象
            console.log("hi")
        }
        return clone; //返回这个对象
    }
    let person = {
        name:"hengheng",
        friends:[
            "xiaobai",
            "xiaohuang",
            "xiaoli"
        ]
    }
    let anotherPerson = createAnother(person)
    anotherPerson.sayHi() //打印出 hi 
    console.log(anotherPerson)

 

这个例子的重点强调是:基于person对象新返回了一个新对象,新返回的anotherPerson对象具有person的所有属性和方法,还有一个新方法是sayHi

寄生式继承的问题:通过寄生式继承给对象添加函数会导致函数难以重用,与构造函数模式类似。

寄生式组合继承

组合继承其实存在效率问题,最主要的效率问题是父类构造函数始终被调用两次,一次是在创建子类原型时调用,领一次是在子类构造函数中调用,本质上,子类原型最终是要包含超类对象的所有实例属性,子类构造函数只要在执行的时重写自己的原型就行了。

基本思想:寄生式组合继承通过盗用构造函数继承属性,但使用混合式原型链继承方法。基本思路是不通过调用父类构造函数给子类原型赋值,而是取得父类原型的一个副本,说到底就是使用寄生式继承来继承父类原型,然后将返回的新对象赋值给子类原型。

为了解决上面的问题,所以需要在混合继承的基础上进行改造。那么如何避免冗余呢?

  • 避免使用 child.prototype = new parent()来继承整个parent实例;
  • 这样将代码改写为 child.prototype = parent.prototype;
  • 那么又会引入一个问题,child.prototype与parent.prototype共用一个空间(在正常继承中,child.prototype应该有自己独立的空间),也就是说一旦我们修改了child.prototype,同时也修改了parent.prototype;
  • 所以继续修改代码为 child.prototype=Object.create(parent.prototype)(在支持ES5的浏览器中可以直接使用),其实这个create的作用跟咱们下面的object()函数的功能是一样的
  • 函数中返回的F即为child.prototype的独立空间

举个栗子:

    // 寄生组合
    function object(o){
        function F(){}  //这个object()函数会创建一个临时构造函数
        F.prototype = o //将传入的对象赋值给这个构造函数的原型,
        return new F()  //然后返回这个临时类型的一个实例,object()是对传入的对象执行了一次浅复制
    }
    function inheritFunc(child,parent){
        let prototype = object(parent.prototype) //创建父类原型的一个副本,也可以写为let prototype = Object.create(parent.prototype)
        prototype.constructor = child   //增强对象 给返回的prototype对象设置constructor属性,解决由于重写原型导致默认constructor丢失的问题
        child.prototype = prototype  //赋值对象 将新创建的对象赋值给子类型的原型
    }

这个inheritFunc()函数实现了寄生式组合继承的核心,这个函数接收两个参数:子类构造函数和父类构造函数,在这个函数内部,注意:

第一步 是创建父类原型的一个副本,然后给返回的prototype对象设置constructor属性

第二步 是解决由于重写原型导致默认constructor丢失的问题,constructor的指向问题(改不改都不影响),原来返回的F.constructor指向parent,要修改为指向child

最后将新创建的对象赋值给子类型的原型,那么接下来,调用inheritFunc()就可以实现前面例子中的子类型原型赋值:

    function parent(type){
        this.type = type
        this.children = ['c1','c2']
    }
    parent.prototype.say = function(){
        console.log(this.type+" "+this.name+":这是我的孩子们"+this.children)
    }
    function child(type,name){
        parent.call(this,type)//借用构造函数 继承属性
        this.name = name
    }

    inheritFunc(child,parent)//原型链,用于继承parent.prototype(say方法)上的方法
    var p = new child("worker","suoh")
    p.say() //worker suoh:这是我的孩子们c1,c2
    console.log(p)

    var v = new child("student","wweiq")
    v.children.push("禽兽")
    v.say() //student wweiq:这是我的孩子们c1,c2,禽兽
    p.say() //worker suoh:这是我的孩子们c1,c2
    console.log(v)

    

这里只调用了一次parent构造函数,避免了child.prototype上不必要也用不到的属性,因此可以说这个例子的效率更高,而且原型链仍保持不变,因此可以说寄生式组合继承是引用类型继承的最佳模式。

总结

JS的继承主要通过原型链来实现,原型链涉及把构造函数的原型赋值为另一个类型的实例。这样一来,子类就可以访问父类的所有属性和方法,就像基于类的继承那样。

  1. 原型链 的问题是所有继承的树形和方法都会在对象视力健共享,无法做到实例私有。
  2. 盗用构造函数 模式通过在子类构造函数中调用父类构造函数,可以避免这个问题。这样可以让每个实例竭诚的树形都是私有的,但要求类型只能通过构造函数模式来定义(因为子类不能访问父类原型上的方法)。
  3. 组合继承 最为流行,即通过原型链继承共享的属性和方法,通过盗用构造函数来继承实例属性。
  4. 原型式继承 可以无需明确定义构造函数二实现继承,本质上是对给定对象执行浅复制,这个操作的结构之后还可以再进一步增强。
  5. 寄生式继承 与原型式继承密切相关,即先基于一个对象创建一个新对象,然后再增强这个新对象,最后返回新对象,这个模式也被用在组合继承中,用于避免重复调用父类构造函数导致的浪费。
  6. 寄生组合继承 被认为是实现基于类型继承的最有效的方式。

最后想说ES6新增的类很大程度是基于既有原型极致的语法糖,类的语法让开发者可以优雅的定义向后兼容的类,既可以继承内置类型,也可以继承自定义类型。类有效地跨越了对象实例、对象原型和对象类之间的鸿沟,,,那么关于类的继承是怎么一回事呢,待后续更新讲解。

Grey Hack v0.7.3618 保姆级教程:手把手教你用metaxploit.so写一个自动提权脚本 本文详细介绍了如何在Grey Hack v0.7.3618中使用metaxploit.so库编写自动化提权脚本。从环境准备到核心功能解析,再到漏洞利用链构建和权限提升的智能处理,手把手教你掌握游戏中的高级黑客技巧。通过多库联合利用和错误处理优化,提升脚本的效率和成功率。 阅读详情

相关推荐

python k线顶分型_【缠论】分型、笔的定义及其程序化

K线包含关系处理和分型的定义如果一个K线的高低点全在另一K线的范围里,称之为包含关系。针对这种K线,需要进行一些处理,去除包含关系,处理方法:向上时,把两K线的高点当高点,而两K线低点中的较高者当成低点;反之,当向下时,把两K线的低点当低点,而两K线高点中的较低者当成高点,这样就把两K线合并成一新的K线。经过这样的处理,所有K线图都可以处理成没有包含关系的图形。两K线的包含关系,可以分成四种:1)...

weixin_39717152的博客 2830

Js实现继承的6种方式

Js实现继承的6种方式: 1.原型链继承 2.借用构造函数继承 3.组合继承(经典继承) 4.原型式继承 方法一: 方法二:Object.create() 5.寄生式继承 6.寄生组合式继承 7.ES6、Class实现继承

wuliyouMaozhi的博客 2万+

图文带你理解什么是Few-shot Learning

Few-shot Learning(少样本学习)是Meta Learning(元学习)中的一个实例1,所以在了解什么是Few-shot Learning之前有必要对Meta Learning有一个简单的认识。不过在了解什么是Meta Learning之前还是要了解一下什么是Meta。因此,阅读本文后你将对如下知识有一个初步的了解。 What is Meta What is Meta Learning What is Few-shot Learning 1. What is Meta? meta就是描述

Pr4da的博客 1万+

JS中的八种继承方法

详细讲解js中的八种继承方法,原型链继承、构造函数继承(经典继承)、组合面试、原型式继承、Object.create()、寄生式继承、寄生组合式继承、ES6类继承

weixin_70134200的博客 6646

rockchip rk3566 android11 网口log报错: DMA engine initialization failed

问题描述:上电初始化前将网口插入,然后上电初始化网口能够正常使用,且能够找到PHY,ifconfig 查看能够有eth0 产生,网口正常使用且能够热插拔,但上电初始化时,不插入网口,就会报DMA engine initialization failed 错误,DMA 初始化的时候出错了。 分析:一般产生这个问题可以认为是GMAC 的工作时钟出问题了。先测量时钟引脚是否有时钟,时钟频率以及幅度等指标是否正常,主要确认以下几个方面: 1.IOMUX 出错,检查时钟脚寄存器值是否正确。 2.时钟方向以及配置

qq_48709036的博客 2万+

tewa-707e光猫超级密码获取方法

这款光猫很魔性,没有WIFI,没有USB接口,没有Telnet,试了很多方法去获取超级密码都不行。解密时可能会报错,可能是文件后面部分不晓得是咋拼接过来的,用AES解密时分组数据有问题。3、这个文件是用AES加密了的,直接打开是乱码,所以得用AES解密,key为16个字节的 x00。打开解出来的文件,然后搜索 telecomadmin,就可以发现超级密码了。参考资料里面的光猫不是同一款,但解密的方法基本相同的。

shaowl111的专栏 1万+

js的六种继承方式

1、原型链继承 核心: 将父类的实例作为子类的原型 特点: 1.非常纯粹的继承关系,实例是子类的实例,也是父类的实例 2.父类新增原型方法/原型属性,子类都能访问到 3.简单,易于实现缺点: 1.要想为子类新增属性和方法,必须要在new Animal()这样的语句之后执行,不能放到构造器中 2.无法实现多继承 3.来自原型对象的所有属性被所有实例共享(来自原型对象的引用属性是所有实例共享的) 4.创建子类实例时,无法向父类构造函数传参2、构造函数继承(借助 call) 核心:使用父类的构造函数来增强子类实例

weixin_41759744的博客 7748

向华为学习——IPD流程体系之IPD术语

《IPD体系核心概念与业务术语解析》摘要: IPD(集成产品开发)是一种以市场为导向的结构化产品开发管理模式,通过跨部门协作、异步开发、CBB(通用构建模块)和管道管理等手段,实现产品全生命周期高效管理。体系包含七大核心要素:跨部门团队(如IPMT决策层、PDT执行层)、结构化流程(分阶段评审)、端到端项目管理(WBS分级计划)、客户需求分析、投资组合优化及质量管控(TR技术评审)。各业务领域术语涵盖财务(NPV、IRR)、开发(需求分解、基线化)、制造(可制造性设计)、采购(Sourcing团队)及市场(

cdfunlove的博客 483

【笔记】JS实现继承的几种方式

JS实现继承的几种方式

weixin_44755080的博客 2689

商品标签识别系统:基于YOLO系列的深度学习实现

随着零售行业的快速发展和自动化需求的增长,商品标签识别技术变得越来越重要。本文详细介绍了一个完整的商品标签识别系统,该系统基于YOLO系列目标检测算法(包括YOLOv5、YOLOv8和YOLOv10),采用PySide6构建用户界面,并提供完整的训练代码和数据集处理方案。该系统能够准确识别商品标签中的关键信息,如价格、条形码、生产日期等,为零售自动化、库存管理和智能结算提供技术支持。

YOLO 351

python批量调用大模型API:多线程和异步协程

本文介绍了利用多线程技术批量调用大模型API的实现方法。核心是通过并发请求提高处理效率,主要采用线程池管理并发数量、结果聚合等技术。文章提供了一个完整的Python实现示例,包含APIBatchCaller类及其single_api_call和batch_call方法,详细解析了并发控制、错误处理等关键点,并给出了使用注意事项,包括并发数设置、重试策略和超时处理等。该方案特别适合IO密集型任务,能显著提升批量API调用的效率。

Cachel Wood的博客 761

总结JS继承的六种方式

1. 继承 1.1语法 //父类 classFather{ } //子类继承父类 classSonextendsFather{ } 例如: classFather{ constructor(sonname){ this.sonname=sonname; } say(){ console.log('你的姓是'+this.sonname); ...

AI_huihui的博客 1万+

matlab处理las点云(1)——las/laz格式解析【2024最新版】

matlab中的las/laz格式解析。博客长期更新,本文最近一次更新时间为:2024年11月9日。

点云侠的博客 8464

JavaScript六种继承方式

本文详细介绍了JavaScript中的6种继承方式:原型链继承、借用构造函数继承、组合继承、原型式继承、寄生式继承以及最优的寄生组合式继承,分析了每种方式的实现原理、优缺点及适用场景。特别详细解析了寄生组合式继承如何通过Object.create()巧妙解决组合继承的缺陷,成为ES6 class继承的底层实现。文章建议现代开发直接使用ES6的class语法,其简洁安全且基于最优继承方案,避免手动处理原型链的复杂性。不同继承方式各有特点,理解这些原理对掌握JavaScript面向对象编程至关重要。

2302_76681576的博客 1913

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

理解js继承的六种方式

原型链继承 原型链继承是ECMAScript的主要继承方式。其基本思想就是通过原型继承多个引用类型的属性和方法。什么是原型链?每个构造函数都会有一个原型对象,调用构造函数创建的实例会有一个指针__proto__指向原型对象,这个原型可能是另一个类型的实例,所以内部可能也有一个指针指向另一个原型,然后就这样形成了一条原型链。 代码: function SuperType() { this.property = true; } SuperType.prototype.getSuperValue = fun

qq_42736311的博客 7722

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

js基础之六种继承方式

概述 在JavaScript中,存在六种继承模式,分别是基本继承(即前文js基础之原型链提到的最原始的方式,暂未查到官方称谓)、借用构造函数、组合继承、原型式继承、寄生式继承和寄生组合式继承。其中组合继承是基本继承和借用构造函数的组合版本,也是最常用的继承;原型式继承是基本继承的“干净”版本(只继承原型);寄生式继承是原型式继承的工厂化版本;寄生组合式继承是组合继承融入原型式继承思想后的优化版本,...

夕山雨的博客 1673

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

JS继承六种方式详解

js继承的6种方式: 想要继承,就必须要提供个父类(继承谁,提供继承的属性) 继承在js中占有非常重要的地位,那么在js中有很多中继承的方式,不过每一种继承方式都有优缺点。下面就列举几种继承的方式: 一、原型链继承 父类的实例作为子类的原型 优点: 简单易于实现,父类的新增的实例与属性子类都能访问 缺点: 可以在子类中增加实例属性,如果要新增加原型属性和方法需要在new 父类构造函数的后面 无法实现多继承 创建子类实例时,不能向父类构造函数中传参数 二、借用构造函数继承(伪造对象

Zheng_xinle的博客 913

大前端之路----JS继承的六种方式

JS继承的六种方式[原型]// B是A的原型,A是B的构造函数 A.prototype = B B.constructor = A [约定]// 父类 function Super(){ this.property = 'Super Property' } Super.prototype.getProperty = function(){ return this.property } 一.构

caijixin的博客 2万+

js 六种继承方式介绍及优缺点

js继承方式

混世小妲己 1759

JS的六种继承方式

最近还整理一份JavaScript与ES的笔记,一共25个重要的知识点,对每个知识点都进行了讲解和分析。能帮你快速掌握JavaScript与ES的相关知识,提升工作效率。

小王的技术库 2118

JS实现继承的六种方式

// 第一种方式:对象冒充(不推荐) // 注意:此种继承方式对象实例化后在编译器中继承对象(children)不会代码提示父类的方法(parent) // function Parent(username) { // this.username = username // this.getUsername = function () { // console.log(this.username) // } // } // function Children(user

冻书的博客 383

JavaScript 常见的六种继承方式

JavaScript 常见的六种继承方式 继承是面向对象软件技术当中的一个概念,与多态、封装共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。 一、原型链继承 prototype 子类型的原型为父类型的一个实例对象。 父类 function Parent(name, age) { this.name = name, this.age = age, this.play = [1, 2, 3] this.setName = functio

guoqkmiss的博客 579

js常见的六种继承方式

然后,createObject函数通过增强新对象的方式,在新对象上添加了sayName方法,从而实现继承和增强。然后,将子类的原型设置为临时构造函数的实例,从而实现了对父类原型的继承。寄生组合式继承是指通过借用构造函数来继承实例属性,然后通过将原型设置为一个继承父类原型的实例来继承父类原型上的属性和方法。这种方式的缺点是所有新对象的实例属性都会共享obj对象的属性,导致无法实现真正意义上的继承。原型式继承是指通过使用一个已有的对象作为新对象的原型来创建新对象,从而实现继承。,从而创建了一个新的对象,并将。

weixin_46369590的博客 1252

JavaScript常见的六种继承方式

面向对象编程很重要的一个方面,就是对象的继承。A 对象通过继承 B 对象,就能直接拥有 B 对象的所有属性和方法。这对于代码的复用是非常有用的。 大部分面向对象的编程语言,都是通过“类”(class)实现对象的继承。传统上,JavaScript 语言的继承不通过 class(ES6 引入了class 语法),而是通过“原型对象”(prototype)实现。那么在JS中常见的继承方式有几种呢? 方式一、原型链继承 //父类型 function Animal(name) { this.name

CFSBD的博客 2044

javascript的六种基本继承方式

javascript的六种基本继承方式 在js中万物皆对象,对象又分为两种:普通对象(Object)和函数对象(Function)。 任何对象都具有隐式原型属性( __ proto __ ),只有函数对象有显式原型属性(prototype)。 如果需要继承,我们就首先要定义父类: function Person (name) { this.name = name; this.skill = f...

lh9456的博客 256

好程序员分享JavaScript六种继承方式详解

好程序员 分享 JavaScript 六种继承方式详解 , 继承是面向对象编程中又一非常重要的概念, JavaScript ...

cique2620的博客 145
上一篇: 含泪也要看--async和await的使用与原理
下一篇: 安装Docker、配置阿里镜像加速、Docker运行流程、Docker常用命令
suoh's Blog
博客等级 码龄9年 4万+粉丝 283原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

suoh's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址