JavaScript原型与原型链深入探究使用方法

目录
  • 原型(prototype)
    • 显示原型与隐式原型
  • 原型链
    • 原型链属性问题
    • 原型链 instanceof 使用
    • 练习

原型(prototype)

每一个函数都有一个 prototype 属性,它默认指向一个Object空对象(即称为:原型对象)。

<script>
    console.log(Date.prototype, typeof Date.prototype);
    function fun(){
    }
    fun.prototype.test = function(){ //给原型对象添加一个方法
        console.log('test()');
    }
    console.log(fun.prototype); // 默认指向一个Object空对象(没有我们的属性)
</script>

原型对象中有一个属性 constructor ,它指向函数对象。

<script>
    function fun(){
    }
    console.log(Date.prototype.constructor === Date);
    console.log(fun.prototype.constructor === fun);
</script>

给原型对象添加属性(一般是方法) ===> 实例对象可以访问。

有的时候我们想要在所有已经存在的对象添加新的属性或方法。

另外,有时候我们想要在对象的构造函数中添加属性或方法。

使用 prototype 属性就可以给对象的构造函数添加新的属性:

<script>
    function fun(){
    }
    fun.prototype.test = function(){//给原型对象添加方法(属性)
        console.log('test()');
    }
    var fn = new fun()//函数的所有实例对象自动拥有原型中的方法(属性)
    fn.test()
</script>

显示原型与隐式原型

每一个函数 function 都有一个 prototype,即显示原型。默认指向一个空的 Object 对象。

<script>
    function fun(){
    }
    console.log(fun.prototype);
</script>

每个实例对象都有一个 __proto__ ,可称为隐式原型。

<script>
    function fun(){
    }
    var fn = new fun()
    console.log(fn.__proto__);
</script>

对象的隐式原型的值 为其对应 构造函数的显示原型的值。

<script>
    function fun(){
    }
    // console.log(fun.prototype);
    var fn = new fun()
    // console.log(fn.__proto__);
    console.log(fun.prototype === fn.__proto__); //结果是 true
</script>

总结:

函数的 prototype 属性:在定义函数时自动添加的,默认值是一个空的 Object 对象。

对象的 __proto__ 属性:创建对象时自动添加的,默认值为构造函数的 prototype 属性值。

程序员能直接操作显示原型,但不能直接操作隐式原型(ES6之前)。

原型链

原型链(本质为:隐式原型链,作用:查找对象的属性或方法),访问一个对象的属性时,先在自身属性中查找,找到返回;如果没有,再沿着 __proto__ 这条链向上查找,找到返回;如果最终没找到,返回 undefined。

<script>
    console.log(Object.prototype.__proto__);
    function Fun(){
        this.test1 = function(){
            console.log('test1()');
        }
    }
    console.log(Fun.prototype);
    Fun.prototype.test2 = function(){
        console.log('test2()');
    }
    var fun = new Fun()
    fun.test1()
    fun.test2()
    console.log(fun.toString())
    fun.test3()
</script>

总结:

JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时,它不仅仅在该对象上搜寻,还会搜寻该对象的原型,以及该对象的原型的原型,依次层层向上搜索,直到找到一个名字匹配的属性或到达原型链的末尾。

<script>
    function Fun(){
    }
    //函数的显示原型指向的对象默认是空 Object 实例对象(但 Object 不满足)
    console.log(Fun.prototype instanceof Object);
    console.log(Object.prototype instanceof Object);
    console.log(Function.prototype instanceof Object);
    //所有函数都是 Function 的实例(包括 Function)
    console.log(Function.__proto__ === Function.prototype);
    // Object 的原型对象是原型链的尽头
    console.log(Object.prototype.__proto__);
</script>

原型链属性问题

读取对象的属性值时:会自动查找到原型链中查找;设置对象属性时:不会查找原型链,如果当前对象中没有此属性,直接添加此属性值并设置其值;方法一般定义在原型中,属性一般通过构造函数定义在对象本身上。

<script>
    function Fun(){
    }
    Fun.prototype.a = 'xxx'
    var fun = new Fun()
    console.log(fun.a,fun);
    var fun1 = new Fun()
    fun1.a = 'yyy'
    console.log(fun.a,fun1.a,fun1);
    function Person(name,age){
        this.name = name
        this.age = age
    }
    Person.prototype.setName = function(name){
        this.name = name
    }
    var p1 = new Person('Tom',12)
    p1.setName('Bob')
    console.log(p1);
    var p2 = new Person('Jack',12)
    p2.setName('andy')
    console.log(p2);
    console.log(p1.__proto__ === p2.__proto__);
</script>

原型链 instanceof 使用

表达式:A instanceof B ;如果B函数的显示原型对象在A对象的原型链中,返回true,否则返回false;Function是通过new自己产生的实例。

<script>
    function Fun(){}
    var fn = new Fun()
    console.log(fn instanceof Fun);
    console.log(fn instanceof Object);
    console.log(Object instanceof Function);
    console.log(Object instanceof Object);
    console.log(Function instanceof Function);
    console.log(Function instanceof Object);
    function Foo(){}
    console.log(Object instanceof Foo);
</script>

练习

<script>
    function A(){}
    A.prototype.n = 1
    var b = new A()
    A.prototype = {
        n:2,
        m:3
    }
    var c = new A()
    console.log(b.n, b.m, c.n, c.m);
</script>

其实现原理如下图所示(图有点草,凑合看吧哈哈)

<script>
    function F(){}
    Object.prototype.a = function(){
        console.log('a()');
    }
    Function.prototype.b = function(){
        console.log('b()');
    }
    var f = new F()
    f.a()
    F.a()
    F.b()
    console.log(f);
    console.log(Object.prototype);
    console.log(Function.prototype);
</script>

到此这篇关于JavaScript原型与原型链深入探究使用方法的文章就介绍到这了,更多相关JS原型与原型链内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

时间: 2022-11-06

一文彻底理解JavaScript原型与原型链

目录 前言 new对函数做了什么? 原型和原型链 借用原型方法 实现构造函数之间的继承 方案一 方案二 class extends实现继承 结语 前言 JavaScript中有许多内置对象,如:Object, Math, Date等.我们通常会这样使用它们: // 创建一个JavaScript Date实例 const date = new Date(); // 调用getFullYear方法,返回日期对象对应的年份 date.getFullYear(); // 调用Date的now方法 //

JavaScript原型和原型链与构造函数和实例之间的关系详解

目录 原型 原型链 原型 如图所示: 1.instanceof检测构造函数与实例的关系: function Person () {.........} person = new Person () res = person instanceof Person res  // true 2.实例继承原型上的定义的属性: function Person () {........} Person.prototype.type = 'object n' person = new Person () re

JavaScript原型链及常见的继承方法

目录 原型链 原型链的概念 原型链的问题 几种常见的继承方法 盗用构造函数 组合继承 原型式继承 寄生式继承 寄生组合式继承 原型链 原型链的概念 在JavaScript中,每一个构造函数都有一个原型,这个原型中有一个属性constructor会再次指回这个构造函数,这个构造函数所创造的实例对象,会有一个指针(也就是我们说的隐式原型__proto__或者是浏览器中显示的[[Prototype]])指向这个构造函数的原型对象.如果说该构造函数的原型对象也是由另外一个构造函数所创造的实例,那么该构造

一文搞懂JavaScript中原型与原型链

目录 1.构造函数原型prototype 2.对象原型__proto__ 3.constructor构造函数 4.原型链 5.原型对象中的this指向 6.扩展内置对象(原型对象的应用) 在ES6之前,我们面向对象是通过构造函数实现的.我们把对象的公共属性和方法放在构造函数里 像这样: function student(uname,age) { this.uname = uname; this.age = age; this.school = function() { console.log('

JavaScript三大重点同步异步与作用域和闭包及原型和原型链详解

目录 1. 同步.异步 2. 作用域.闭包 闭包 作用域 3. 原型.原型链 原型(prototype) 原型链 如图所示,JS的三座大山: 同步.异步 作用域.闭包 原型.原型链 1. 同步.异步 JavaScript执行机制,重点有两点: JavaScript是一门单线程语言 Event Loop(事件循环)是JavaScript的执行机制 JS为什么是单线程 最初设计JS是用来在浏览器验证表单操控DOM元素的是一门脚本语言,如果js是多线程的,那么两个线程同时对一个DOM元素进行了相互冲突

Javascript 原型与原型链深入详解

目录 前言 对象 原型 原型链 javascript中的类 new的实现 instanceof的实现 javascript的继承 总结 前言 在前端这块领域,原型与原型链是每一个前端 er 必须掌握的概念.多次在面试或者一些技术博客里面看见这个概念.由此可见,这个玩意对于前端来说有多重要.其实它本身理解起来不难,但是很多刚入行前端的同学,看到prototype.__proto__理解起来还是有点吃力,然后脑子里面就乱成一锅粥,就像我一样. 但是这是很正常的事情,没什么大不了的,就像我们想要学会跑

三张图带你搞懂JavaScript的原型对象与原型链

对于新人来说,JavaScript的原型是一个很让人头疼的事情,一来prototype容易与__proto__混淆,二来它们之间的各种指向实在有些复杂,其实市面上已经有非常多的文章在尝试说清楚,有一张所谓很经典的图,上面画了各种线条,一会连接这个一会连接那个,说实话我自己看得就非常头晕,更谈不上完全理解了.所以我自己也想尝试一下,看看能不能把原型中的重要知识点拆分出来,用最简单的图表形式说清楚. 我们知道原型是一个对象,其他对象可以通过它实现属性继承.但是尼玛除了prototype,又有一个__

JavaScript原型链中函数和对象的理解

目录 __ proto__ prototype.__ proto__ 理解 __ proto__ 最近在看高程4,原型链肯定是绕不过的,本瓜之前一直认为,只要记住这句话就可以了: 一个对象的隐式原型(__proto__)等于构造这个对象的构造函数的显式原型(prototype) 确实,所有对象都符合这句真理,在控制台打印一试便知: const str = new String("123") str.__proto__ === String.prototype // true const

Javascript原型链和原型的一个误区

之前我对Javascript的原型链中, 原型继承与标识符查找有些迷惑, 如, 如下的代码: 复制代码 代码如下: function Foo() {}; var foo = new Foo(); Foo.prototype.label = "laruence"; alert(foo.label); //output: laruence alert(Foo.label);//output: undefined 今天看到了如下这个图: Javascript object layout 另外

JavaScript原型链与继承操作实例总结

本文实例讲述了JavaScript原型链与继承操作.分享给大家供大家参考,具体如下: 1. JavaScript继承 JavaScript继承可以说是发生在对象与对象之间,而原型链则是实现继承的主要方法: 1.1 原型链 利用原型让一引用类型继承另一个引用类型的属性和方法. 构造函数中有个prototype(每个函数中都有),指向他的原型对象,每个原型对象中也有一个constructor属性,指向原构造函数.通过构造函数创建的新对象中都有一个无法直接访问的[[proto]]属性,使得对象也指向构

深入浅出理解javaScript原型链

本文实例讲述了javaScript的原型链.分享给大家供大家参考.具体分析如下: 对于javascript原型链,以前都觉得是个很深的东西,一直没有理解很明白,今天看了一些介绍后,发现这张图,表示再没有什么语言能比这张图说得清楚了. 看了这张图后突然对javascript有了质的理解. javascript的原型链有显式和隐式两种: 显式原型链:即我们常见的prototype: 隐式原型链:在一般环境下无法访问,即不可见,在FireFox下可以通过__proto__方式访问:隐式原型链用于jav

javascript原型链继承用法实例分析

本文实例分析了javascript原型链继承的用法.分享给大家供大家参考.具体分析如下: 复制代码 代码如下: function Shape(){   this.name = 'shape';   this.toString = function(){    return this.name;   }  }    function TwoDShape(){   this.name = '2D shape';  }  function Triangle(side,height){   this.n

Javascript原型链的原理详解

本文实例分析了Javascript原型链的原理.分享给大家供大家参考,具体如下: 一.JavaScript原型链 ECMAScript中描述了原型链的概念,并将原型链作为实现继承的主要方法.其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法.在JavaScript中,用 __proto__ 属性来表示一个对象的原型链.当查找一个对象的属性时,JavaScript 会向上遍历原型链,直到找到给定名称的属性为止! 比如现在有如下的代码: 扩展Object类,添加Clone和Extend

javascript原型链学习记录之继承实现方式分析

本文实例讲述了javascript原型链学习记录之继承实现方式.分享给大家供大家参考,具体如下: 在慕课网学习继承的笔记: 继承的几种方式: ① 使用构造函数实现继承 function Parent(){ this.name = 'parent'; } function Child(){ Parent.call(this); //在子类函数体里面执行父类的构造函数 this.type = 'child';//子类自己的属性 } Parent.call(this),this即实例,使用this执行

Vue中函数防抖节流的理解及应用实现

防抖和节流的目的都是为了减少不必要的计算,不浪费资源,只在适合的时候再进行触发计算. 一.函数防抖 定义 在事件被触发n秒后再执行回调,如果在这n秒内又被触发,则重新计时:典型的案例就是输入搜索:输入结束后n秒才进行搜索请求,n秒内又输入的内容,就重新计时. 实现原理 函数防抖的基本思想是设置一个定时器,在指定时间间隔内运行代码时清楚上一次的定时器,并设置另一个定时器,知道函数请求停止并超过时间间隔才会执行. 使用场景 文本框输入搜索(连续输入时避免多次请求接口) 代码实现 /** * 函数防抖

了解Javascript中函数作为对象的魅力

Javascript赋予了函数非常多的特性,其中最重要的特性之一就是将函数作为第一型的对象.那就意味着在javascript中函数可以有属性,可以有方法, 可以享有所有对象所拥有的特性.并且最重要的,她还可以直接被调用 我们简单的试验一下就可以发现 // 简单实验 函数作为对象的存在 let fn = function () {} fn.prop = 'fnProp' console.log(fn.prop) // fnProp 为函数添加属性的这个特性我觉的大家在平时的开发中基本没什么尝试或者

理解JavaScript原型链

每一个JavaScript对象都和另一个对象相关联,相关联的这个对象就是我们所说的"原型".每一个对象都会从原型继承属性和方法.有一个特殊的对象没有原型,就是Object.在之后的图示中会进行说明. 举个栗子,我们首先声明一个函数Student(): function Student(name){ this.name = name; this.hello = function(){ alert(`Hello,${this.name}`); } } 这个函数包含一个属性name和一个方法

JavaScript原型链示例分享

复制代码 代码如下: <mce:script type="text/javascript"><!--/*   每个对象实例都有个属性成员用于指向到它的instanceof 对象(暂称为父对象)的原型(prototype)   我们把这种层层指向父原型的关系称为[原型链 prototype chian]   原型也具有父原型,因为它往往也是一个对象实例,除非我们人为地去改变它   在JavaScript中,"一切都是对象,函数是第一型."   Fun