精华内容
下载资源
问答
  • 一个例子让你彻底明白原型对象和原型链 开篇 之前对js中的原型链和原型对象有所了解,每当别人问我什么是原型链和原型对象时,我总是用很官方(其实自己不懂)的解释去描述。有一句话说的好:如果你不能把一个很复杂...
  • 对于js的原型和原型链理解

    万次阅读 多人点赞 2019-06-23 22:20:23
    一、原型与原型链 JavaScript是一门基于原型的语言,在软件设计模式中,有一种模式叫做原型模式,JavaScript正是利用这种模式而被创建出来 原型模式是用于创建重复的对象,同时又能保证性能,这种类型的设计模式...

    一、原型与原型链

    1. JavaScript是一门基于原型的语言,在软件设计模式中,有一种模式叫做原型模式,JavaScript正是利用这种模式而被创建出来
    2. 原型模式是用于创建重复的对象,同时又能保证性能,这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。原型模式的目的是用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象,也就是说利用已有的一个原型对象,可以快速地生成和原型对象一样的新对象实例
    3. 原型:一个可以被复制(或者叫克隆)的一个类,通过复制原型可以创建一个一模一样的新对象,也可以说原型就是一个模板,在设计语言中更准确的说是一个对象模板
      1)原型是定义了一些公用的属性和方法,利用原型创建出来的新对象实例会共享原型的所有属性和方法
      实例代码:
        // 创建原型
        var Person = function(name){
            this.name = name;
        };
    
        // 原型的方法
       Person.prototype.sayHello = function(){
           console.log(this.name+",hello");
       };
    
       // 实例化创建新的原型对象,新的原型对象会共享原型的属性和方法
       var person1 = new Person("zhangsan");
       var person2 = new Person("lisi");
    
       // zhangsan,hello
       person1.sayHello();
       // lisi,hello
       person2.sayHello();
    

    2)严格模式下,原型的属性和方法还是会被原型实例所共享的
    实例代码:

        // 开启严格模式,原型的属性和方法还是会被原型实例所共享的
       "use strict";
    
        // 创建原型
        var Person = function(name){
            this.name = name;
        };
    
        // 原型的方法
       Person.prototype.sayHello = function(){
           console.log(this.name+",hello");
       };
    
       // 实例化创建新的原型对象,新的原型对象会共享原型的属性和方法
       var person1 = new Person("zhangsan");
       var person2 = new Person("lisi");
    
       // zhangsan,hello
       person1.sayHello();
       // lisi,hello
       person2.sayHello();
    

    3)通过原型创建的新对象实例是相互独立的,为新对象实例添加的方法只有该实例拥有这个方法,其它实例是没有这个方法的
    实例代码:

        // 创建原型
        var Person = function(name){
            this.name = name;
        };
    
        // 原型的方法
       Person.prototype.sayHello = function(){
           console.log(this.name+",hello");
       };
    
       // 实例化创建新的原型对象,新的原型对象会共享原型的属性和方法
       var person1 = new Person("zhangsan");
       var person2 = new Person("lisi");
    
       // zhangsan,hello
       person1.sayHello();
       // lisi,hello
       person2.sayHello();
    
       
       // 为新对象实例添加方法
       // 通过原型创建的新对象实例是相互独立的
       person1.getName = function(){
           console.log(this.name);
       }
    
       // zhangsan
       person1.getName();
       // Uncaught TypeError: person2.getName is not a function
       person2.getName();
    

    4)原型的总结

    • 所有引用类型都有一个__proto__(隐式原型)属性,属性值是一个普通的对象
    • 所有函数都有一个prototype(原型)属性,属性值是一个普通的对象
    • 所有引用类型的__proto__属性指向它构造函数的prototype

    5)函数的原型prototype:函数才有prototype,prototype是一个对象,指向了当前构造函数的引用地址
    6)函数的原型对象__proto__:所有对象都有__proto__属性, 当用构造函数实例化(new)一个对象时,会将新对象的__proto__属性指向 构造函数的prototype
    7)原型对象和函数的原型的关系
    在这里插入图片描述
    说明

    • 所有函数的__proto__都是指向Function的prototype
    • 构造函数new出来的对象__proto__指向构造函数的prototype
    • 非构造函数实例化出的对象或者对象的prototype的__proto__指向Object的prototype
      Object的prototype指向null

    8)所有的原型对象都会自动获得一个 constructor(构造函数)属性,这个属性(是一个指针)指向 prototype 属性所在的函数(Person)
    9)实例的构造函数属性(constructor)指向构造函数 :person1.constructor == Person
    10)原型对象(Person.prototype)是 构造函数(Person)的一个实例
    11)原型的分类:
    隐式原型(_proto_):上面说的这个原型是JavaScript中的内置属性[[prototype]],此属性继承自object对象,在脚本中没有标准的方式访问[[prototype]],但Firefox、Safari和Chrome在每个对象上都支持一个属性_proto_,隐式原型的作用是用来构成原型链,实现基于原型的继承
    显示原型(prototype):每一个函数在创建之后,便会拥有一个prototype属性,这个属性指向函数的原型对象,显示原型的作用是用来实现基于原型的继承与属性的共享
    12)原型的使用方式
    通过给Calculator对象的prototype属性赋值对象字面量来设定Calculator对象的原型
    在赋值原型prototype的时候使用function立即执行的表达式来赋值,可以封装私有的function,通过return的形式暴露出简单的使用名称,以达到public/private的效果

    1. 原型链
      1)原型链:原型链是原型对象创建过程的历史记录,当访问一个对象的某个属性时,会先在这个对象本身属性上查找,如果没有找到,则会去它的__proto__隐式原型上查找,即它的构造函数的prototype,如果还没有找到就会再在构造函数的prototype的__proto__中查找,这样一层一层向上查找就会形成一个链式结构
      2)原型设计的问题:当查找一个对象的属性时,JavaScript 会根据原型链向上遍历对象的原型,直到找到给定名称的属性为止,直到到达原型链的顶部仍然没有找到指定的属性,就会返回 undefined
      也可以理解为原型链继承时查找属性的过程是先查找自身属性,当自身属性不存在时,会在原型链中逐级查找
      3)hasOwnProperty 函数:可以用来检查对象自身是否含有某个属性,返回值是布尔值,当属性不存在时不会向上查找对象原型链,hasOwnProperty是 JavaScript 中唯一一个处理属性但是不查找原型链的函数
      4)getOwnPropertyNames 函数:可以获取对象所有的自身属性,返回值是由对象自身属性名称组成的数组,同样不会向上查找对象原型链
      5)原型链的小结
    • 一直往上层查找,直到到null还没有找到,则返回undefined
    • Object.prototype.__proto__ === null
    • 所有从原型或更高级原型中的得到、执行的方法,其中的this在执行时,指向当前这个触发事件执行的对象

    6)JavaScript的原型是为了实现对象间的联系,解决构造函数无法数据共享而引入的一个属性,而原型链是一个实现对象间联系即继承的主要方法

    二、原型与原型链的常见面试题

    1. 谈谈你对原型的理解
      在 JavaScript 中,每当定义一个对象(函数也是对象)时候,对象中都会包含一些预定义的属性。其中每个函数对象都有一个prototype 属性,这个属性指向函数的原型对象,使用原型对象的好处是所有对象实例共享它所包含的属性和方法

    2. 什么是原型链?原型链解决的是什么问题
      1)原型链解决的主要是继承问题
      2)每个对象拥有一个原型对象,通过 proto 指针指向其原型对象,并从中继承方法和属性,同时原型对象也可能拥有原型,这样一层一层,最终指向 null(Object.proptotype.__proto__指向的是null)。这种关系被称为原型链(prototype chain),通过原型链一个对象可以拥有定义在其他对象中的属性和方法
      3)构造函数 Parent、Parent.prototype 和 实例 p 的关系如下:(p.__proto__ === Parent.prototype)
      在这里插入图片描述

    3. prototype 和 proto 区别是什么
      1)prototype是构造函数的属性
      2)__proto__是每个实例都有的属性,可以访问 [[prototype]] 属性
      3)实例的__proto__与其构造函数的prototype指向的是同一个对象

    展开全文
  • 理解原型和原型链 原型和原型链学了很久,但是一直没有完全理解,虽然现在也没用完全理解,但能勉强对付一下了 这里面先参考一下 阮大大的教程 前言 要先从继承开始讲起,根据其他语言比如java或者c++来说,他们都可以...

    理解原型和原型链

    原型和原型链学了很久,但是一直没有完全理解,虽然现在也没用完全理解,但能勉强对付一下了

    这里面先参考一下 阮大大的教程

    前言

    要先从继承开始讲起,根据其他语言比如java或者c++来说,他们都可以通过new来创建一个实例对象,然后js也出现了new的关键字,但是new后面不能跟着类,必须要跟着构造函数

    new运算符的缺点

    用构造函数生成实例对象,有一个缺点,那就是无法共享属性和方法。

    理解

    随之而来prototype属性引入

    任何一个实例对象创建之后,将自动引用prototype对象的属性和方法,例如下面

    function Dog(name){
        this.name = name
    }
    Dog.prototype.sayName = function(){ console.log(this.name) }
    var dog = new Dog('小明')
    dog.sayName()
    

    那么每一个通过Dog构造函数实例化出来的对象,都会有sayName的这个方法

    prototype

    每个对象拥有一个原型对象,对象以原型为模板,从原型集成方法和属性,这些属性和方法定义在对象的构造器函数的 prototype 属性上,而非对象实例本身,

    一个例子

    function Parent() {}
    var p = new Parent();
    p.__proto__ === Parent.prototype
    

    这里用 p.proto 获取对象的原型,proto 是每个实例上都有的属性,prototype 是构造函数的属性,这两个并不一样,但 p.proto 和 Parent.prototype 指向同一个对象。

    总结

    1. prototype和__proto__的区别,prototype是构造函数上面的属性,而__proto__是实例出来的对象的属性,这两个并不一样,但 p.proto 和 Parent.prototype 指向同一个对象

    2. 再说的俗一些 _proto_里是js内置的,prototype是你自己写的。比如当我们去创建一个 var obj = {} 的时候,他会默认就有 obj.toString() 这个方法,这就是__ptoto__的方式,而如果我们想增加,就在他的原型构造函数上面添加 prototpye

    3. 原型链: 每个对象都有一个原型对象,通过__proto__指针指向上一个原型,并从中继承方法和属性,同时原型对象也有原型,那么一层一层可以找下去,直到null,这种关系我们称之为原型链

    4. 原型: JavaScript 常被描述为一种基于原型的语言——每个对象拥有一个原型对象,对象以其原型为模板、从原型继承方法和属性。

    展开全文
  • 本文实例讲述了javascript 原型与原型链理解及应用。分享给大家供大家参考,具体如下: javascript中一切皆对象,但是由于没有Class类的概念,所以就无法很好的表达对象与对象之间的关系了。 比如对象A与对象B之间...
  • 主要介绍了javascript原型链和继承的概念,以及使用原型链实现继承、经典继承、组合式继承、寄生组合式继承。非常实用,是篇非常不错的文章,这里推荐给大家。
  • 原型链理解起来有点绕了,网上资料也是很多,每次晚上睡不着的时候总喜欢在网上找点原型链闭包的文章看,效果极好。 不要纠结于那一堆术语了,那除了让你脑筋拧成麻花,真的不能帮你什么。简单粗暴点看原型链吧,...
  • 原型和原型链是我们在面试中必会提问到的一个问题,理解原型和原型链不管对学习还是工作都会得到帮助,希望这篇文章会帮助你理解原型和原型链。 一、原型对象 原型对象分为两种,隐式原型(proto)显式原型...

    原型和原型链是我们在面试中必会提问到的一个问题,理解原型和原型链不管对学习还是工作都会得到帮助,希望这篇文章会帮助你理解原型和原型链。

    一、原型对象

    原型对象分为两种,隐式原型(proto)和显式原型(prototype),
    所有函数都有prototype属性(显式原型)仅限函数
    所有引用类型(数组、对象、函数)都拥有__proto__属性(隐式原型)

    二、原型

    先来看一个原型例子

    function Foo(name,age){
    	this.name = name;
    	this.age = age;
    }
    Foo.prototype = {
    	getName:function(){
    		return '我是'+this.name
    	},
    	getAge:function(){
    		return '我今年'+this.age
    	}
    }
    
    const w = new Foo('Q','XX');
    console.log(w.getName()) //我是Q
    console.log(w.getAge()) //我今年XX
    /*当调用getName和getAge方法时,若这个实例不存在该方法,那么就会去它构造函数的 prototype 中去找*/
    

    这就是原型,理解起来比较容易,那为什么要使用原型呢?
    假如我们用Foo创建跟多个对象,不使用原型的话是这样:

    function Foo(name,age){
    	this.name = name;
    	this.age = age;
    	this.getName = function (){
    		return '我是'+this.name
    	};
    	this.getAge = funciton (){
    		return '我今年'+this.age
    	}
    }
    

    这样来实现的话回对我们的代码带来极大的不便,不易维护,还会占用很多的资源。
    通过原型来实现的话,只需要在构造函数里面给属性赋值,把方法写在prototype属性(这个属性是唯一的),这样每个对象都可以调用prototype属性里面的getName、getAge方法,节省了不少的资源和维护成本。

    三、原型链

    理解原型链稍微有一些绕,我们先看一下代码

    Function.prototype.a = 'a';
    Object.prototype.b = 'b';
    function Foo(){};
    let f = new Foo();
    console.log(f.a); //undefined 
    console.log(f.b); //b
    

    运行上面代码,我们会发现为什么f.a是undefined呢?这就是原型链机制影响的。

    console.log(typeof f.__proto__.__proto__); //object
    

    打印f.b的结果为b,但f没有b属性,就会一直通过__proto__往上找,最后当查找到Object.prototype时找到,最后打印出b,向上查找过程中,得到的是Object.prototype,而不是Function.prototype,找不到a属性,所以结果为undefined,这就是原型链,通过__proto__向上进行查找,最终到null结束。

    展开全文
  • 原型  大家都知道,JavaScript 不包含传统的类继承模型,而是使用 prototype 原型模型。代码实现大概是这样子的 function Student(name){ this.name = name; } var Kimy = new Student("Kimy"); Student....
  • 原型链】每个构造函数都有一个对象,原型对象都包含一个指向构造函数的指针,而实例都包含一个指向原型对象的内部指针。那么,如果原型对象等于另一个原型的实例,此时的原型对象将包含一个指向另一个原型的指针,...
  • 主要大家一起深入理解JS原型与原型链,原型是JavaScript中一个比较难理解的概念,本文为大家解决这个难题,感兴趣的小伙伴们可以参考一下
  • 对于javascript原型链,以前都觉得是个很深的东西,一直没有理解很明白,今天看了一些介绍后,发现这张图,表示再没有什么语言能比这张图说得清楚了。 看了这张图后突然对javascript有了质的理解。 javascript的...
  • 原型和原型链理解

    千次阅读 多人点赞 2019-09-09 09:39:47
    原型和原型链理解:(面试题) 原型:每个函数都有 prototype 属性,该属性指向原型对象;使用原型对象的好处是所有对象实例共享它所包含的属性方法。 原型链:主要解决了继承的问题;每个对象都拥有一个原型对象...

    原型链

    原型链

    原型和原型链的理解:(面试题)

    • 原型:每个函数都有 prototype 属性,该属性指向原型对象;使用原型对象的好处是所有对象实例共享它所包含的属性和方法。
    • 原型链:主要解决了继承的问题;每个对象都拥有一个原型对象,通过__proto__ 指针指向其原型对象,并从中继承方法和属性,同时原型对象也可能拥有原型,这样一层一层,最终指向 null。

    原型的作用:
    1.数据共享 节约内存内存空间
    2.实现继承
    注意:函数也是一个对象,对象不一定是函数。(对象有__proto__属性,函数有prototype属性)此处说明,方便大家理解下文。
    下面我将举例说明为什么要使用原型
    例1:

    
    function Person(name) {
        this.name=name;
        this.eat=function () {
    
            console.log(this.name+"吃东西");
        }
    
        this.sleep=function () {
    
            console.log(this.name+"睡觉");
        }
    
    }
    var p1=new Person("小明");
    p1.eat();//小明吃东西
    p1.sleep();//小明睡觉
    var p2=new Person("小利");
    p2.eat();//小利吃东西
    p2.sleep();//小利睡觉
    console.dir(p1);//dir()打印结构
    console.dir(p2);
    

    执行结果图

    每次使用构造函数Person()实例化出对象的时候,就会给每个实例对象的eat()方法和sleep()方法开辟空间。可是当实例化许多对象的时候,就会浪费大量的空间,因为每个实例对象的eat()方法和sleep()的功能都是一样的,所以我们没必要为每个实例对象添加eat()方法和sleep()方法。

    这时原型就派上用场了,看下面经过改造的例子:
     

    
    function Person(name) {
        this.name=name;
    }
    Person.prototype.eat=function () {
        console.log(this.name+"吃东西");
    };
    Person.prototype.sleep=function () {
        console.log(this.name+"睡觉");
    }
    var p1=new Person("小明");
    p1.eat();//小明吃东西
    p1.sleep();//小明睡觉
    var p2=new Person("小利");
    p2.eat();//小利吃东西
    p2.sleep();//小利睡觉
    console.dir(p1);
    console.dir(p2);
    

    执行结果

    eat()方法和sleep()被添加到了Person()构造函数的原型(prototype)上了。因此只有一份eat()方法和sleep()方法。当实例对象需要使用这些方法的时候就在自己的__proto__属性中找到并调用这些方法实现相应的功能。

    现在我们来捋一下构造函数,实例对象,原型对象之间的关系。

    如以下代码和图所示:

    Person()构造函数的prototype属性是一个对象,实例对象p1的__proto__属性也是一个对象,并且prototype对象和__proto__对象的指向相同。那么我们再回过头来理解一下为什么添加到原型的方法可以是共享的。因为prototype对象和__proto__对象的指向相同,所以将eat()方法和sleep()添加到Person()构造函数的prototype属性上之后,实例对象就可以通过自己__proto__属性去访问eat()方法和sleep()了。

    console.dir(Person);
    console.dir(p1);
    console.log(typeof p1.__proto__);//object
    console.log(typeof Person.prototype);//object
    console.log(p1.__proto__ === Person.prototype);//true
    

    执行效果

    关系图

    __proto__指向该对象所在的构造函数的原型对象。

    实例对象和构造函数之间没用直接的关系。原型对象与实例对象之间用原型(__proto__)关联,这种关系叫做原型链。

    我是这样理解原型链的(可能不是很准确)我向我爸要零花钱,我爸也没有钱,那么我就向我奶奶要,奶奶要是也没有,就继续找别人要。

    那么原型的指向可以改变吗?答案是可以的。

    举个例子:
     

    function Person(name) {
        this.name=name;
    }
    Person.prototype.eat=function () {
        console.log(this.name+"吃东西");
    };
    Person.prototype.sleep=function () {
        console.log(this.name+"睡觉");
    }
    function Student(school) {
        this.school=school;
    }
    Student.prototype.write=function () {
        console.log("写作业");
    }
    Student.prototype=new Person("小华");//改变Student()构造函数的指向,让Student()构造函数的原型对象指向Person的实例对象
    var s1=new Student("某某高中");
    s1.eat();//小华吃东西
    s1.sleep();//小华睡觉
    s1.write();//Uncaught TypeError: s1.write is not a function,因为Student()的原型的指向改变,所以找不到write()方法
    console.dir(Student);
    console.dir(s1);
    

    执行结果

    代码图解

    __proto__指向该对象所在的构造函数的原型对象。如上图所示:Studend()构造函数的原型(prototype)指向了Person()的实例对象(new Person("小华")),所以Studend()的实例对象s1的__proto__也指向了Person()的实例对象((new Person("小华"))。而实例对象((new Person("小华"))的__proto__指向了其所在的构造函数Person()的原型对象在这个原型对象中,找到了eat()方法和sleep()方法。

    从这个例子中,可以发现,利用原型可以实现继承。面向对象的编程语言中有(class)类的概念,但是JavaScript不是面向对象的语言,所以js中没有类(class)(ES6中实现了class),但是js可以模拟面向对象的思想编程,js中通过构造函数来模拟类的概念。

    改变原型的指向可以实现方法的继承。借用构造函数继承,主要解决属性的问题
     

    function Person(name) {
        this.name=name;
    }
    Person.prototype.eat=function () {
        console.log(this.name+"吃东西");
    };
    Person.prototype.sleep=function () {
        console.log(this.name+"睡觉");
    }
    function Student(name,school) {//name为父类构造器传参。子类构造器可以添加自己特有的属性school
        Person.call(this,name);//调用父类构造器Person的属性,
        this.school=school;
    }
    Student.prototype.write=function () {
        console.log("写作业");
    }
    Student.prototype=new Person();//改变Student()构造函数的指向,让Student()构造函数的原型对象指向Person的实例对象
    var s1=new Student("zx","某某高中");
    s1.eat();//小华吃东西
    s1.sleep();//小华睡觉
    console.dir(Student);
    console.dir(s1);
    

    组合继承就是指:将改变原型的指向和借用构造函数两者结合在一起实现继承。 

    一、原型模式

    我们创建的每一个函数都有一个prototype(原型)属性,这个属性指向的是通过调用构造函数来创建出来的对象实例原型对象,这个原型对象可以让所有对象实例共享它所包含的属性和方法。

    function Person () {
        
    }
    Person.prototype.name = "xiao";
    Person.prototype.sayName = function () {
        alert('this.name')
    }
    var person1 = new Person();
    var person2 = new Person();
    person1.sayName()  
    console.log(person1.name == person2.name)   // "true"

    上面的例子当中我们创建了一个构造函数Person,并通过它的prototype属性在它的原型对象中定义了name属性并赋值,然后通过调用构造函数Person实例化出来两个对象实例,通过打印出来的值我们可以得知,person1person2共享了原型对象中的属性和方法。

    构造函数,原型对象和对象实例的关系

    我们知道每个函数都有一个prototype属性指向函数的原型对象。在默认情况下,所有原型对象都有一个constructor(构造函数)属性,这个属性指向了prototype属性所在的函数,比如前面的例子中,Person.prototype.constructor就指向Person
    另外,当调用构造函数创建一个新实例后,该实例的内部将包含一个__porto__属性(仅在Firefox、Safari、Chrome中支持),这个属性指向的就是构造函数的原型对象。由此我们可以得出以下图示的结论:

    通过代码来验证:

    # 实例和原型对象之间的关系
    console.log(person.__proto__ == Person.prototype) // true
    
    # 也可以通过isPrototypeOf()和ES5中的Object.getPrototypeOf()方法来判断
    console.log(Person.prototype.isPrototypeOf(person1)) // true
    console.log(Object.getPrototypeOf(person) === Person.prototype) // true
    
    # 原型对象和构造函数的关系
    console.log(Person.prototype.constructor == Person) // true

    二、原型链

    通过前面我们对构造函数,对象实例和原型对象三者关系的描述可知,实例都包含了指向原型对象的内部指针。
    那么假如现在我们有两个构造函数AB,我们让构造函数A的原型对象等于构造函数B的实例,根据前面的推论,这个时候A的原型对象就包含指向B的原型对象的指针,再假如又有一个构造函数C,让A的原型对象等于C的实例,上述关系依旧成立,以此类推便形成了实例与原型的链条,即原型链,它主要作为JS中实现继承的主要方法。

    原型链的基本实现

    function SuperType() {
        this.property = true;
    }
    SuperType.prototype.getSuperValue = function() {
        return this.property;
    }
    
    # 继承了SuperType
    SubType.prototype = new SuperType();
    SubType.prototype.getSubValue = function() {
        return this.subproperty;
    }
    
    var instance = new SubType();
    console.log(instance.SuperValue()); // true

    在上面的代码中,我们没有使用SubType默认的原型,而是将SuperType的实例赋给它,重写了SubType的原型对象;这样一来SubType.prototype的内部便具有一个指向SuperType原型的指针,原来存在于SuperType的实例中的所有属性和方法,现在也存在于SubType.prototype中了。
    instance同理,还要注意的是由于SubType的原型指向了SuperType的原型,而SuperType的原型的constructor属性指向的是SuperType构造函数,那么instance.constructor也就指向了SuperType

    原型搜索机制:

    当访问一个实例属性或方法时,在通过原型链实现继承的情况下,首先会在实例中搜索该属性,在没有找到属性或方法时,便会沿着原型链继续往上搜索,直到原型链末端才会停下来。
    这里还有一个重要的点,事实上所有引用类型默认都继承了Object,而这个继承也是通过原型链实现的,也就是说,所有函数的默认原型都是Object的实例,这也是所有自定义类型都会继承toString()valueOf()等默认方法的根本原因。

    Object.prototype的原型

    既然所有类型默认都继承了Object,那么Object.prototype又指向哪里呢,答案是null,我们可以通过下面的代码打印试试看:

    console.log(Object.prototype.__proto__ === null) // true

    null即没有值,也就是说属性或方法的查找到Object.prototype就结束了。

    展开全文
  • 原型:JS声明构造函数(用来实例化对象的函数)时,会在内存中创建一个对应的对象,这个对象就是原函数的原型。构造函数默认有一个prototype属性,prototype的值指向函数的原型。同时原型中也有一个constructor属性,...
  • 强大的原型和原型链

    2018-07-24 09:21:04
    JavaScript 不包含传统的类继承模型,而是使用 prototypal 原型模型。...由于 JavaScript 是唯一一个被广泛使用的基于原型继承的语言,所以理解两种继承模式的差异是需要一定时间的,今天我们就来了解一下原型和原型链
  • 由于 JavaScript 是唯一一个被广泛使用的基于原型继承的语言,所以理解两种继承模式的差异是需要一定时间的,今天我们就来了解一下原型和原型链。 原型 10年前,我刚学习JavaScript的时候,一般都是用如下方式来写...
  • 本文实例讲述了JS原型和原型链原理与用法。分享给大家供大家参考,具体如下: Javascript语言的继承机制一直很难被人理解。 它没有”子类””父类”的概念,也没有”类”(class)”实例”(instance)的区分,...
  • 1.原型 每创建一个函数,都有一个prototype属性,该属性指向一个对象,这个对象就是原型。 选择一些属性方法... 因此,当所有的实例都能够proto放问到原型对象时,原型对象的方法与属性就变成共有的方法属性。
  • 深入理解JS原型与原型链(一)

    千次阅读 2018-12-14 14:46:38
    分为普通对象函数对象,Object 、Function 是 JS 自带的函数对象。下面举例说明 var o1 = {}; var o2 =new Object(); var o3 = new f1(); function f1(){}; var f2 = function(){}; var f3 = new...
  • prototype:每个函数都有一个prototype属性,它默认指向一个object空对象(即称为:原型对象)。原型对象中有个属性constructor,它指向该函数对象。 xianshi
  • 彻底理解原型和原型链 原型是什么? 先来说一下构造函数,构造函数的作用就是创建初始化一个对象。通过new来创建一个实例,由构造函数创建的实例与实例之间是相互独立的。 每个构造函数都会有一个prototype属性,...
  • 要弄清楚原型链就要先弄清楚 function 类型,在javascript中没有类的概念,都是函数,所以它是一门函数式的编程语言。类有一个很重要的特性,就是它可以根据它的构造函数来创建以它为模板的对象。在javascript中,...
  • 原型是JavaScript中一个比较难理解的概念,原型相关的属性也比较多,对象有”prototype”属性,函数对象有”prototype”属性,原型对象有”constructor”属性。 一、初识原型 在JavaScript中,原型也是一个对象,...
  • js原型链与继承是js中的重点,原型的实现则是在原型链的基础上,本篇文章深入理解JS继承和原型链的问题,有兴趣的同学可以了解一下。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,514
精华内容 39,005
关键字:

原型和原型链理解