彻底搞懂JS原型与原型链

彻底搞懂 JavaScript 原型、隐式原型与原型链 理解JavaScript中的原型、隐式原型和原型链对于掌握面向对象编程至关重要。通过这些机制,我们可以实现灵活且高效的代码复用和继承结构。希望本文能帮助你全面理解这些核心概念,并在实际开发中加以应用。 阅读详情

说到JavaScript的原型和原型链,相关文章已有不少,但是大都晦涩难懂。本文将换一个角度出发,先理解原型和原型链是什么,有什么作用,再去分析那些令人头疼的关系。

一、引用类型皆为对象

原型和原型链都是来源于对象而服务于对象的概念,所以我们要先明确一点:

JavaScript中一切引用类型都是对象,对象就是属性的集合。

Array类型、Function类型、Object类型、Date类型、RegExp类型等都是引用类型。

也就是说 数组是对象、函数是对象、正则是对象、对象还是对象。

二、原型和原型链是什么

上面我们说到对象就是属性(property)的集合,有人可能要问不是还有方法吗?其实方法也是一种属性,因为它也是键值对的表现形式,具体见下图。

可以看到obj上确实多了一个sayHello的属性,值为一个函数,但是问题来了,obj上面并没有hasOwnProperty这个方法,为什么我们可以调用呢?这就引出了 原型。

每一个对象从被创建开始就和另一个对象关联,从另一个对象上继承其属性,这个另一个对象就是 原型。

当访问一个对象的属性时,先在对象的本身找,找不到就去对象的原型上找,如果还是找不到,就去对象的原型(原型也是对象,也有它自己的原型)的原型上找,如此继续,直到找到为止,或者查找到最顶层的原型对象中也没有找到,就结束查找,返回undefined。

这条由对象及其原型组成的链就叫做原型链。

现在我们已经初步理解了原型和原型链,到现在大家明白为什么数组都可以使用push、slice等方法,函数可以使用call、bind等方法了吧,因为在它们的原型链上找到了对应的方法。

OK,总结一下:

  1. 原型存在的意义就是组成原型链:引用类型皆对象,每个对象都有原型,原型也是对象,也有它自己的原型,一层一层,组成原型链。
  2. 原型链存在的意义就是继承:访问对象属性时,在对象本身找不到,就在原型链上一层一层找。说白了就是一个对象可以访问其他对象的属性。
  3. 继承存在的意义就是属性共享:好处有二:一是代码重用,字面意思;二是可扩展,不同对象可能继承相同的属性,也可以定义只属于自己的属性。

三、创建对象

对象的创建方式主要有两种,一种是new操作符后跟函数调用,另一种是字面量表示法。

目前我们现在可以理解为:所有对象都是由new操作符后跟函数调用来创建的,字面量表示法只是语法糖(即本质也是new,功能不变,使用更简洁)。

// new操作符后跟函数调用
let obj = new Object()
let arr = new Array()

// 字面量表示法
let obj = { a: 1}
// 等同于
let obj = new Object()
obj.a = 1

let arr = [1,2]
// 等同于
let arr = new Array()
arr[0] = 1
arr[1] = 2

Object、Array等称为构造函数,不要怕这个概念,构造函数和普通函数并没有什么不同,只是由于这些函数常被用来跟在new后面创建对象。new后面调用一个空函数也会返回一个对象,任何一个函数都可以当做构造函数。

所以构造函数更合理的理解应该是函数的构造调用。

Number、String、Boolean、Array、Object、Function、Date、RegExp、Error这些都是函数,而且是原生构造函数,在运行时会自动出现在执行环境中。

构造函数是为了创建特定类型的对象,这些通过同一构造函数创建的对象有相同原型,共享某些方法。举个例子,所有的数组都可以调用push方法,因为它们有相同原型。

我们来自己实现一个构造函数:

// 惯例,构造函数应以大写字母开头
function Person(name) {
  // 函数内this指向构造的对象
  // 构造一个name属性
  this.name = name
  // 构造一个sayName方法
  this.sayName = function() {
    console.log(this.name)
  }
}

// 使用自定义构造函数Person创建对象
let person = new Person('logan')
person.sayName() // 输出:logan

总结一下:构造函数用来创建对象,同一构造函数创建的对象,其原型相同。

四、__proto__与prototype

万物逃不开真香定律,初步了解了相关知识,我们也要试着来理解一下这些头疼的单词,并且看一下指来指去的箭头了。

上面总结过,每个对象都有原型,那么我们怎么获取到一个对象的原型呢?那就是对象的__proto__属性,指向对象的原型。

上面也总结过,引用类型皆对象,所以引用类型都有__proto__属性,对象有__proto__属性,函数有__proto__属性,数组也有__proto__属性,只要是引用类型,就有__proto__属性,都指向它们各自的原型对象。

__proto__属性虽然在ECMAScript 6语言规范中标准化,但是不推荐被使用,现在更推荐使用Object.getPrototypeOf,Object.getPrototypeOf(obj)也可以获取到obj对象的原型。本文中使用__proto__只是为了便于理解。

Object.getPrototypeOf(person) === person.__proto__ // true

上面说过,构造函数是为了创建特定类型的对象,那如果我想让Person这个构造函数创建的对象都共享一个方法,总不能像下面这样吧:

错误示范

// 调用构造函数Person创建一个新对象personA
let personA = new Person('张三')
// 在personA的原型上添加一个方法,以供之后Person创建的对象所共享
personA.__proto__.eat = function() {
    console.log('吃东西')
}
let personB = new Person('李四')
personB.eat() // 输出:吃东西

但是每次要修改一类对象的原型对象,都去创建一个新的对象实例,然后访问其原型对象并添加or修改属性总觉得多此一举。既然构造函数创建的对象实例的原型对象都是同一个,那么构造函数和其构造出的对象实例的原型对象之间有联系就完美了。

这个联系就是prototype。每个函数拥有prototype属性,指向使用new操作符和该函数创建的对象实例的原型对象。

Person.prototype === person.__proto__ // true

看到这里我们就明白了,如果想让Person创建出的对象实例共享属性,应该这样写:

正确示范

Person.prototype.drink = function() {
    console.log('喝东西')
}

let personA = new Person('张三')
personB.drink() // 输出:喝东西

OK,惯例,总结一下:

  1. 对象有__proto__属性,函数有__proto__属性,数组也有__proto__属性,只要是引用类型,就有__proto__属性,指向其原型。
  2. 只有函数有prototype属性,只有函数有prototype属性,只有函数有prototype属性,指向new操作符加调用该函数创建的对象实例的原型对象。
  3. 参考视频讲解:进入学习

五、原型链顶层

原型链之所以叫原型链,而不叫原型环,说明它是有始有终的,那么原型链的顶层是什么呢?

拿我们的person对象来看,它的原型对象,很简单

// 1. person的原型对象
person.__proto__ === Person.prototype

接着往上找,Person.prototype也是一个普通对象,可以理解为Object构造函数创建的,所以得出下面结论,

// 2. Person.prototype的原型对象
Person.prototype.__proto__ === Object.prototype

Object.prototype也是一个对象,那么它的原型呢?这里比较特殊,切记!!!

Object.prototype.__proto__ === null

我们就可以换个方式描述下 原型链 :由对象的__proto__属性串连起来的直到Object.prototype.__proto__(为null)的链就是原型链。

在上面内容的基础之上,我们来模拟一下js引擎读取对象属性:

function getProperty(obj, propName) {
    // 在对象本身查找
    if (obj.hasOwnProperty(propName)) {
        return obj[propName]
    } else if (obj.__proto__ !== null) {
    // 如果对象有原型,则在原型上递归查找
        return getProperty(obj.__proto__, propName)
    } else {
    // 直到找到Object.prototype,Object.prototype.__proto__为null,返回undefined
        return undefined
    }
}

六、constructor

回忆一下之前的描述,构造函数都有一个prototype属性,指向使用这个构造函数创建的对象实例的原型对象。

这个原型对象中默认有一个constructor属性,指回该构造函数。

Person.prototype.constructor === Person // true

之所以开头不说,是因为这个属性对我们理解原型及原型链并无太大帮助,反而容易混淆。

七、函数对象的原型链

之前提到过引用类型皆对象,函数也是对象,那么函数对象的原型链是怎么样的呢?

对象都是被构造函数创建的,函数对象的构造函数就是Function,注意这里F是大写。

let fn = function() {}
// 函数(包括原生构造函数)的原型对象为Function.prototype
fn.__proto__ === Function.prototype // true
Array.__proto__ === Function.prototype // true
Object.__proto__ === Function.prototype // true

Function.prototype也是一个普通对象,所以Function.prototype.__proto__ === Object.prototype

这里有一个特例,Function的__proto__属性指向Function.prototype。

总结一下:函数都是由Function原生构造函数创建的,所以函数的__proto__属性指向Function的prototype属性

八、小试牛刀

真香警告!

有点乱?没事,我们先将之前的知识都总结一下,然后慢慢分析此图:

知识点

  1. 引用类型都是对象,每个对象都有原型对象。
  2. 对象都是由构造函数创建,对象的__proto__属性指向其原型对象,构造函数的prototype属性指向其创建的对象实例的原型对象,所以对象的__proto__属性等于创建它的构造函数的prototype属性。
  3. 所有通过字面量表示法创建的普通对象的构造函数为Object
  4. 所有原型对象都是普通对象,构造函数为Object
  5. 所有函数的构造函数是Function
  6. Object.prototype没有原型对象

OK,我们根据以上六点总结来分析上图,先从左上角的f1、f2入手:

// f1、f2都是通过new Foo()创建的对象,构造函数为Foo,所以有
f1.__proto__ === Foo.prototype
// Foo.prototype为普通对象,构造函数为Object,所以有
Foo.prototype.__proto === Object.prototype
// Object.prototype没有原型对象
Object.prototype.__proto__ === null

然后对构造函数Foo下手:

// Foo是个函数对象,构造函数为Function
Foo.__proto__ === Function.prototype
// Function.prototype为普通对象,构造函数为Object,所以有
Function.prototype.__proto__ === Object.prototype

接着对原生构造函数Object创建的o1、o2下手:

// o1、o2构造函数为Object
o1.__proto__ === Object.prototype

最后对原生构造函数Object和Function下手:

// 原生构造函数也是函数对象,其构造函数为Function
Object.__proto__ === Function.prototype
// 特例
Function.__proto__ === Function.prototype

分析完毕,也没有想象中那么复杂是吧。

如果有内容引起不适,建议从头看一遍,或者去看看参考文章内的文章。

九、举一反三

1. instanceof操作符

平常我们判断一个变量的类型会使用typeof运算符,但是引用类型并不适用,除了函数对象会返回function外,其他都返回object。我们想要知道一个对象的具体类型,就需要使用到instanceof。

let fn = function() {}
let arr = []
fn instanceof Function // true
arr instanceof Array // true
fn instanceof Object // true
arr instanceof Object // true

为什么fn instanceof Object和arr instanceof Object都返回true呢?我们来看一下MDN上对于instanceof运算符的描述:

instanceof运算符用于测试构造函数的prototype属性是否出现在对象的原型链中的任何位置

也就是说instanceof操作符左边是一个对象,右边是一个构造函数,在左边对象的原型链上查找,知道找到右边构造函数的prototype属性就返回true,或者查找到顶层null(也就是Object.prototype.__proto__),就返回false。
我们模拟实现一下:

function instanceOf(obj, Constructor) { // obj 表示左边的对象,Constructor表示右边的构造函数
    let rightP = Constructor.prototype // 取构造函数显示原型
    let leftP = obj.__proto__ // 取对象隐式原型
    // 到达原型链顶层还未找到则返回false
    if (leftP === null) {
        return false
    }
    // 对象实例的隐式原型等于构造函数显示原型则返回true
    if (leftP === rightP) {
        return true
    }
    // 查找原型链上一层
    return instanceOf(obj.__proto__, Constructor)
}

现在就可以解释一些比较令人费解的结果了:

fn instanceof Object //true
// 1. fn.__proto__ === Function.prototype
// 2. fn.__proto__.__proto__ === Function.prototype.__proto__ === Object.prototype
arr instanceof Object //true
// 1. arr.__proto__ === Array.prototype
// 2. arr.__proto__.__proto__ === Array.prototype.__proto__ === Object.prototype
Object instanceof Object // true
// 1. Object.__proto__ === Function.prototype
// 2. Object.__proto__.__proto__ === Function.prototype.__proto__ === Object.prototype
Function instanceof Function // true
// Function.__proto__ === Function.prototype

总结一下:instanceof运算符用于检查右边构造函数的prototype属性是否出现在左边对象的原型链中的任何位置。其实它表示的是一种原型链继承的关系。

2. Object.create

之前说对象的创建方式主要有两种,一种是new操作符后跟函数调用,另一种是字面量表示法。

其实还有第三种就是ES5提供的Object.create()方法,会创建一个新对象,第一个参数接收一个对象,将会作为新创建对象的原型对象,第二个可选参数是属性描述符(不常用,默认是undefined)。具体请查看Object.create()。

我们来模拟一个简易版的Object.create:

function createObj(proto) {
    function F() {}
    F.prototype = proto
    return new F()
}

我们平常所说的空对象,其实并不是严格意义上的空对象,它的原型对象指向Object.prototype,还可以继承hasOwnProperty、toString、valueOf等方法。

如果想要生成一个不继承任何属性的对象,可以使用Object.create(null)。

如果想要生成一个平常字面量方法生成的对象,需要将其原型对象指向Object.prototype:

let obj = Object.create(Object.prototype)
// 等价于
let obj = {}

3. new操作符

当我们使用new时,做了些什么?

  1. 创建一个全新对象,并将其__proto__属性指向构造函数的prototype属性。
  2. 将构造函数调用的this指向这个新对象,并执行构造函数。
  3. 如果构造函数返回对象类型Object(包含Functoin, Array, Date, RegExg, Error等),则正常返回,否则返回这个新的对象。

依然来模拟实现一下:

function newOperator(func, ...args) {
    if (typeof func !== 'function') {
        console.error('第一个参数必须为函数,您传入的参数为', func)
        return
    }
    // 创建一个全新对象,并将其`__proto__`属性指向构造函数的`prototype`属性
    let newObj = Object.create(func.prototype)
    // 将构造函数调用的this指向这个新对象,并执行构造函数
    let result = func.apply(newObj, args)
    // 如果构造函数返回对象类型Object,则正常返回,否则返回这个新的对象
    return (result instanceof Object) ? result : newObj
}

4. Function.__proto__ === Function.prototype

其实这里完全没必要去纠结鸡生蛋还是蛋生鸡的问题,我自己的理解是:Function是原生构造函数,自动出现在运行环境中,所以不存在自己生成自己。之所以Function.__proto__ === Function.prototype,是为了表明Function作为一个原生构造函数,本身也是一个函数对象,仅此而已。

5. 真的是继承吗?

前面我们讲到每一个对象都会从原型“继承”属性,实际上,继承是一个十分具有迷惑性的说法,引用《你不知道的JavaScript》中的话,就是:

继承意味着复制操作,然而 JavaScript 默认并不会复制对象的属性,相反,JavaScript 只是在两个对象之间创建一个关联,这样,一个对象就可以通过委托访问另一个对象的属性,所以与其叫继承,委托的说法反而更准确些。

AMESim柱塞泵建模全指南:从HCD库搭建到联合仿真 液压系统仿真中,轴向柱塞泵的建模始终是难点与热点。柱塞泵结构紧凑、功率密度高,在工程机械与航空航天领域应用广泛,然而其运动学与流体细节深度耦合,给仿真带来不小挑战。AMESim平台中的HCD库提供了一种从物理结构出发的建模思路,将柱塞泵分解为容积腔、节流口与机械约束等基础单元,从而真实刻画柱塞腔压力波动、配流特性和容积效率等关键行为,摆脱黑盒模型的局限。基于机理建模的仿真结果,可用于泵参数优化、故障特征分析以及控制策略验证。进一步结合AMESim与Simulink联合仿真,可以高效开发变量泵排量控制系统,研 阅读详情

相关推荐

RPA机器人技术原理初探

RPA初步

曲折旅程,艰难人生 2142

js原型与原型链详解(万文总结,一文搞懂原型链!)

JavaScript中的原型和原型链:1,每个对象均存在隐式原型(__proto__),函数对象才有prototype属性2,__proto__存在的意义在于为原型链查找提供方向,原型链查找靠的是__proto__,而不是prototype3,函数对象的__proto__都指向Function.prototype4,每个对象都有一个隐式原型属性(__proto__),多个原型通过__proto__链接在一起形成的链式结构就是原型链😃。

Yi_qian的博客 3万+

从稀疏表示到低秩表示(一)

确定研究方向后一直在狂补理论,最近看了一些文章,有了些想法,顺便也总结了representation系列的文章,由于我刚接触,可能会有些不足,愿大家共同指正。 从稀疏表示到低秩表示系列文章包括如下内容: 一、 sparse representation 二、 一、 sparse representation 1  sparsity  一个线性表示解决的问题如下图所示:

彼岸花 3万+

javascript中的原型与原型链

文章目录一、什么是原型二、prototype四、constructor五、实例与原型六、原型的原型七、原型链 一、什么是原型 原型:每一个javascript对象(除null外)创建的时候,都会与之关联另一个对象,这个对象就是我们所说的原型,每一个对象都会从原型中“继承”属性。 例如 var obj = new Object(); 创建一个对象的时候都会同时关联一个对象,如图,关联的这个对象就是新建的对象obj的原型 二、prototype 在JavaScript中,每个函数都有一个prototype属

codewhy的博客 1487

MTK平台高效部署Qwen2.5大模型:从转换到推理全流程解析

本文详细解析了在MTK平台上高效部署Qwen2.5大模型的全流程,涵盖从环境准备、模型转换与量化,到编译部署与上机推理。重点介绍了如何利用MTK GAI部署工具包进行模型转换和量化,以适配MTK硬件,并最终在设备上成功运行Qwen2.5模型,为边缘侧AI应用提供实践指南。

weixin_29041195的博客 510

深入解析DDR5 SDRAM的ODT模式:时序图与状态表实战指南

本文深入解析了DDR5 SDRAM的ODT模式,详细阐述了其五种工作状态及其在读写操作中的动态切换逻辑。通过解读JESD79-5标准中的时序图与状态表,并结合模式寄存器配置实战,为硬件工程师和爱好者提供了优化信号完整性、提升系统稳定性的关键指南。

gpu4optimizer的博客 702

JS原型、原型链到底是什么?

在js的学习中,原型毫无疑问是一个难点,但也是一个不可忽视的重点。在前端面试中也是一个高频考题,在接下来的深入学习中,你会发现原型、原型链等知识点其实并不难。JavaScript是一个面向(原型)对象的语言,对象是属性的集合,除了值类型 ”一切(引用类型)皆为对象“,判断一个变量是不是对象,值类型可以用typeof,引用类型用instanceof。我们可以通过new来创建一个对象,但其实所有对象都是通过函数创建的,而函数也是对象。等等,这好像有点绕,不急,让我们先去了解prototype原型。在JavaSc

梅花寺 8365

【DaVinci Developer实战指南】从入门到精通:软件组件设计与配置全解析

本文详细解析了DaVinci Developer在汽车电子开发中的核心应用,从软件组件设计到配置实战,涵盖Application SWC创建、RunnableEntity设计及Exclusive Area配置等关键环节。通过实际案例分享,帮助开发者快速掌握AUTOSAR架构下的ECU软件开发技巧,提升工作效率与系统稳定性。

weixin_30952535的博客 251

JavaScript原型和原型链(详细解读)

原型和原型链 一、原型概述 1.概念 原型在JavaScript是一个很重要的概念,它是面向对象可以继承的基础。知道吗,JavaScript的设计模式就是原型模式(二十三个经典设计模式之一),正是因为它有这个模式,所以它才十分的灵活。可以基于原型模式实现更多的面向对象设计模式。 二、原型链 1.什么是原型链? 原型链是原型的查找机制,是一条寻址链。其实原型上的方法或属性查找,都是按照一定的顺序沿着原型链进行查找的。如果查找到最后仍然没有找到这个原型和方法,那么JS就会抛出没有这个属性或方法的异常。 2.什么

程麒阁的博客 8758

学Simulink--决策规划场景实例:基于Simulink的智能车辆行为决策仿真

本文基于Simulink平台构建智能车辆变道决策仿真系统,采用MOBIL算法实现"决策-规划-执行"全流程。系统包含自车动力学模型、环境感知模块(含5%噪声)、决策控制器和轨迹规划模块,通过五次多项式实现平滑变道。仿真验证了三种典型工况:正常变道(成功率100%)、邻车拒绝让行和紧急避障,各项指标均满足要求(TTC>3s,横向加速度<2m/s²,决策周期<100ms)。文章详细介绍了建模步骤、核心算法实现和参数配置方法,并提出了强化学习、多车协同等优化方向。该模型为智能

amy_mhd的博客 153

三极管、MOS管和晶体管综合对比——《器件手册--三极管、MOS管和晶体管》

IGBT(Insulated Gate Bipolar Transistor,绝缘栅双极型晶体管)是一种复合全控型电压驱动式功率半导体器件,结合了MOSFET的高输入阻抗、开关速度快的优点和双极型晶体管(BJT)的低导通压降、高电流密度的优点。例如,在NPN型三极管中,当基极电流增加时,集电极电流会按照一定的比例(放大倍数β)增加,这个比例通常在几十到几百之间。在NMOS管中,当栅极相对于源极的电压(Vgs)小于开启电压(Vth)时,漏极和源极之间没有导电沟道,电流无法通过,处于截止状态。

XU157303764的博客 2887

JS中原型和原型链

1.原型的概念 : 对象天生会有属性__proto__,对应的值是对象,这个对象就是原型。原型通过构造函数的prototype属性也可以访问到。 2.原型的作用 :原型上面的属性和方法,默认可以被对象使用。 3.原型的使用场景:我们通常会将对象公共属性放在原型上。 4.原型链的概念:对象一定会有原型,原型是一个对象,是对象就会有原型,所以原型有原型,原型的原型也有原型:当访问对象属性或者方法的时候,先在当前对象找,找不到就去原型中找,再找不到就去原型的原型中找。。。。,直到顶级原型,顶级原型没有,

Mayday_lyl的博客 780

基于STM32L4XX、HAL库的RTL8211FSI-CG以太网收发器(PHY)驱动程序设计

一、简介:RTL8211FSI-CG是Realtek公司生产的一款高性能、低功耗的单端口10/100M以太网收发器(PHY)。它通过RMII(Reduced Media Independent Interface)或MII接口与MAC控制器连接。

zhusl6688的博客 537

「JavaScript深入」彻底搞懂JS原型与原型链

「JavaScript深入」彻底搞懂JS原型与原型链:原因、使用class实现继承、原型、原型链、prototype和proto

XH_jing的博客 1612

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

深度学习工具包 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")

Javascript原型链详解,一文带你彻底搞懂js原型、原型对象及原型链

原型链是 JavaScript 中的一个重要特性,它是实现对象之间继承关系的机制。在 JavaScript 中,每个对象都有一个原型属性,指向另一个对象。当试图访问一个对象的属性或方法时,如果该对象本身没有这个属性或方法,JavaScript 引擎会沿着原型链向上查找,直到找到对应的属性或方法为止。

greatming666的博客 2110

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

彻底搞懂JavaScript原型和原型链

JavaScript是基于原型编程,创建对象是通过克隆对象的形式,不是通过类创建。函数都拥有prototype原型属性,实例化对象的__proto__属性指向这个原型属性,对象可以直接调用原型对象的方法和属性,不用写__proto__再调用,两者效果一致。对象的__proto__指向构造函数的prototype,构造函数的prototype同样是对象,其__proto__指向上一层原型对象,直到,形成原型链。

gaotlantis的博客 4102

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

JS 原型与原型链图解:彻底搞懂的终极指南

在JavaScript中,原型和原型链是非常重要的知识点,只有理解了它们,才能更好地理解js。《javascript高级程序设计》中对原型的描述:每个函数都会创建一个 prototype 属性,这个属性是一个对象,包含应该由特定引用类型的实例共享的属性和方法。实际上,这个对象就是通过调用构造函数创建的对象的原型。使用原型对象的好处是,在它上面定义的属性和方法可以被对象实例共享。简单来讲,原型就是一个对象,可以实现对象的属性和方法的继承。

~~~ 4924

彻底搞懂js原型与原型链

原生的原型链 function fn(){},fn 为 Function的一个实例,原型链为 null -> Object -> Function -> fn: fn.__proto__ === Function.prototype Function.prototype.__proto === Object.prototype Object.protot...

aocandr8991的博客 196

一文带你彻底搞懂JavaScript原型链

JavaScript原型链、函数和对象、原型对象、prototype、__proto__、constructor、 最佳的组合继承方案

童欧巴的博客 597

彻底搞懂js原型,原型链,继承

一、js中的原型和原型链 和其他的面向对象编程语言不同,最开始js并没有引入class的概念,但是js中有在大量使用对象,为了保证对象之间的联系,JavaScript引入了原型与原型链的概念。 1、什么是原型 在js中,每一个构造函数都拥有一个prototype属性,这个属性指向一个对象,也就是原型对象。原型对象默认拥有一个constructor属性,指向指向它的那个构造函数,每个对象都拥有一个隐藏的属性[[prototype]],指向它的原型对象。原型对象就是用来存放实例中共有的那部分属性。 2. 什么是

kellywong的博客 770

彻底搞懂JavaScript 原型对象与原型链

JavaScript 通过原型实现继承机制,核心概念包括: prototype - 构造函数特有的属性,存储共享方法 proto - 所有对象都有的隐式原型,指向构造函数的prototype constructor - 原型对象的属性,指向构造函数本身 原型链是对象通过__proto__串联形成的查找链:实例→构造函数原型→Object.prototype→null。函数也是对象,其__proto__指向Function.prototype。理解这三个属性的归属关系是掌握原型链的关键。

2501_92864729的博客 1156

彻底搞懂JS原型链

原型链 Object既是对象又是函数。 内置匿名函数:一个函数生成了Object和Function。f(){native code} 根源原型对象:就是一个对象,里边有根源的一些方法,toString,valueOf,constructor等.Object.prototype Object的原型链 Object.prototype//根源原型对象 Object.prototype.__proto__//null Object.__proto__//内置匿名函数f(){native code} Obje

qq_41110700的博客 718

JavaScript 原型与原型链:一篇彻底搞懂

## 摘要 本文系统梳理 JavaScript 原型与原型链的核心机制。从构造函数入手,阐明每个函数都拥有 `prototype` 属性,每个对象都拥有 `__proto__` 内部链接,揭示实例对象的原型指向构造函数原型对象的本质关系。深入讲解原型链的构成——对象沿原型层层向上查找属性直至 `null` 的完整路径,并剖析 `constructor` 属性、属性遮蔽、原型链构建方式等关键概念。最后探讨原型链在方法共享、框架源码中的实际应用,以及原型链污染等安全考量,帮助读者彻底掌握这一 JavaScri

macowl的博客 377
上一篇: 一文读懂Js中的this指向
下一篇: 前端懒加载和预加载
hellocoder2029
博客等级 码龄4年 15粉丝 80原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值