您的位置:澳门新葡8455最新网站 > Web前端 > JS核心系列,JS原型链和访问对象原型的方法

JS核心系列,JS原型链和访问对象原型的方法

发布时间:2019-11-14 16:55编辑:Web前端浏览(107)

    JS核心系列:浅谈 原型对象和原型链

    2016/03/01 · JavaScript · 2 评论 · 原型对象, 原型链

    原文出处: 一像素   

    在Javascript中,万物皆对象,但对象也有区别,大致可以分为两类,即:普通对象(Object)和函数对象(Function)。

    一般而言,通过new Function产生的对象是函数对象,其他对象都是普通对象。

    举例说明:

    function f1(){ //todo } var f2 = function(){ //todo }; var f3 = new Function('x','console.log(x)'); var o1 = {}; var o2 = new Object(); var o3 = new f1(); console.log( typeof f1,//function typeof f2,//function typeof f3,//function typeof o1,//object typeof o2,//object typeof o3 //object ); >> function function function object object object

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    function f1(){
        //todo
    }
    var f2 = function(){
        //todo
    };
    var f3 = new Function('x','console.log(x)');
     
    var o1 = {};
    var o2 = new Object();
    var o3 = new f1();
     
    console.log(
        typeof f1,//function
        typeof f2,//function
        typeof f3,//function
        typeof o1,//object
        typeof o2,//object
        typeof o3 //object
    );
    >> function function function object object object

    f1属于函数的声明,最常见的函数定义方式,f2实际上是一个匿名函数,把这个匿名函数赋值给了f2,属于函数表达式,f3不常见,但也是一种函数对象。

    Function是JS自带的对象,f1,f2在创建的时候,JS会自动通过new Function()的方式来构建这些对象,因此,这三个对象都是通过new Function()创建的。

    在Javascript中创建对象有两种方式:对象字面量和使用new表达式,o1和o2的创建恰好对应了这两种方式,重点讲一下o3, 如果用Java和C#的思路来理解的话,o3是f1的实例对象,o3和f1是同一类型,至少我以前这么认为,其实不然…

    那么怎么理解呢? 很简单,看o3是不是通过new Function产生的, 显然不是,既然不是函数对象,那就是普通对象 。

    通过对函数对象和普通对象的简单理解之后,我们再来了解一下Javascript中的原型和原型链:

    在JS中,每当创建一个函数对象f1 时,该对象中都会内置一些属性,其中包括prototype和__proto__,  prototype即原型对象,它记录着f1的一些属性和方法。

    需要注意的是,prototype 对f1是不可见的,也就是说,f1不会查找prototype中的属性和方法。

    function f(){} f.prototype.foo = "abc"; console.log(f.foo); //undefined

    1
    2
    3
    function f(){}
    f.prototype.foo = "abc";
    console.log(f.foo); //undefined

    那么,prototype有什么用呢? 其实prototype的主要作用就是继承。 通俗一点讲,prototype中定义的属性和方法都是留给自己的“后代”用的,因此,子类完全可以访问prototype中的属性和方法。

    想要知道f1是如何把prototype留给“后代”,我们需要了解一下JS中的原型链,此时,JS中的 __proto__ 入场了,这哥们长的很奇特,隐藏的也很深,以致于你经常见不到它,但它在普通对象和函数对象中都存在, 它的作用就是保存父类的prototype对象,JS在通过new 表达式创建一个对象的时候,通常会把父类的prototype赋值给新对象的__proto__属性,这样,就形成了一代代传承…

    function f(){} f.prototype.foo = "abc"; var obj = new f(); console.log(obj.foo); //abc

    1
    2
    3
    4
    function f(){}
    f.prototype.foo = "abc";
    var obj = new f();
    console.log(obj.foo); //abc

    现在我们知道,obj中__proto__保存的是f的prototype, 那么f的prototype中的__proto__中保存的是什么呢? 看下图:

    澳门新葡8455最新网站 1

    如图所示,f.prototype的__proto__中保存的是Object.prototype,Object.prototype对象中也有__proto__,而从输出结果看,Object.prototype.__proto__ 是null,表示obj对象原型链的终结。如下图所示:

    澳门新葡8455最新网站 2

    obj对象拥有这样一个原型链以后,当obj.foo执行时,obj会先查找自身是否有该属性,但不会查找自己的prototype,当找不到foo时,obj就沿着原型链依次去查找…

    在上面的例子中,我们在f的prototype上定义了foo属性,这时obj就会在原型链上找到这个属性并执行。

     

    最后,用几句话总结一下本文中涉及到的重点:

    1. 原型链的形成真正是靠__proto__ 而非prototype,当JS引擎执行对象的方法时,先查找对象本身是否存在该方法,如果不存在,会在原型链上查找,但不会查找自身的prototype。
    2. 一个对象的__proto__记录着自己的原型链,决定了自身的数据类型,改变__proto__就等于改变对象的数据类型。
    3. 函数的prototype不属于自身的原型链,它是子类创建的核心,决定了子类的数据类型,是连接子类原型链的桥梁。
    4. 在原型对象上定义方法和属性的目的是为了被子类继承和使用。

     

    2 赞 17 收藏 2 评论

    澳门新葡8455最新网站 3

    大家好,我是IT修真院深圳分院第01期学员,一枚正直纯洁善良的web程序员。

    今天给大家分享一下,修真院官网JS(职业)任务4,深度思考中的知识点——JS原型链和访问对象原型的方法

    1.介绍

    JavaScript 中,万物皆对象。JavaScript根据"原型链"(prototype chain)模式,来实现继承。

    2.涉及

    2.1对象

    JavaScript中,对象是有区别的,分为普通对象和函数对象,Object ,Function 是JS自带的函数对象,function定义方式本质上还是new Function方式。

    function  f1(){};

    var f2 = function(){};

    var f3 = new Function('str','console.log(str)');

    var o3 = new f1();

    var o1 = {};

    var o2 =new Object();

    console.log(typeof  Object);  //function

    console.log(typeof  Function);  //function

    console.log(typeof o1);   //object

    console.log(typeof o2);   //object

    console.log(typeof o3);   //object

    console.log(typeof  f1);   //function

    console.log(typeof  f2);   //function

    console.log(typeof  f3);   //function

    2.2对象继承

    Brendan Eich参考C++和Java,做了简化设计,将new命令引入JavaScript中,new后面跟对象的构造函数,用来创建对象。这样做有个缺点:无法共享方法和属性。

    比如,在DOG对象的构造函数中,设置一个实例对象的共有属性species。

    function DOG(name){

    this.name = name;

    this.species = '犬科';

    }

    然后,生成两个实例对象:

    var dogA = new DOG('大毛');

    var dogB = new DOG('二毛');

    这两个对象的species属性是独立的,修改其中一个,不会影响到另一个。

    dogA.species = '猫科';

    alert(dogB.species); // 显示"犬科",不受dogA的影响

    每一个实例对象,都有自己的属性和方法的副本。这不仅无法做到数据共享,也是极大的资源浪费。

    Brendan Eich决定为构造函数设置一个prototype属性。这个属性包含一个对象,所有实例对象需要共享的属性和方法,都放在这个对象里面;那些不需要共享的属性和方法,就放在构造函数里面。实例对象一旦创建,将自动引用prototype对象的属性和方法。也就是说,实例对象的属性和方法,分成两种,一种是本地的,另一种是引用的。

    function DOG(name){

    this.name = name;

    }

    DOG.prototype = { species : '犬科' };

    var dogA = new DOG('大毛');

    var dogB = new DOG('二毛');

    alert(dogA.species); // 犬科

    alert(dogB.species); // 犬科

    species属性放在prototype对象里,是两个实例对象共享的。只要修改了prototype对象,就会同时影响到两个实例对象。

    DOG.prototype.species = '猫科';

    alert(dogA.species); // 猫科

    alert(dogB.species); // 猫科

    由于所有的实例对象共享同一个prototype对象,那么从外界看起来,prototype对象就好像是实例对象的原型,而实例对象则好像"继承"了prototype对象一样。

    2.3原型prototype

    在JavaScript 中,每当定义一个对象(函数)时候,对象中都会包含一些预定义的属性。其中函数对象的一个属性就是原型对象 prototype。普通对象没有prototype,但有__proto__属性。

    示例:

    function  f1(){};

    console.log(f1. prototype) //f1 {}

    console.log(typeof  f1. prototype) //object

    console.log(typeof  Function. prototype) // function

    console.log(typeof  Object. prototype) // object

    console.log(typeof  Function. prototype. prototype) //undefined

    2.4 原型链

    JS在创建对象(不论是普通对象还是函数对象)的时候,都有一个叫做__proto__的内置属性,用于指向创建它的函数对象的原型对象prototype。

    var person = function(name){

    this.name = name

    };

    person.prototype.getName = function(){

    return this.name;

    }

    var zjh = new person(‘zhangjiahao’);

    zjh.getName(); //zhangjiahao

    以上面的例子为例:

    console.log(zjh.__proto__ === person.prototype) //true

    同样,person.prototype对象也有__proto__属性,它指向创建它的函数对象(Object)的prototype

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

    继续,Object.prototype对象也有__proto__属性,但它比较特殊,为null

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

    我们把这个有__proto__串起来的直到Object.prototype.__proto__为null的链叫做原型链。

    2.5 constructor属性

    prototype对象有一个constructor属性,默认指向prototype对象所在的构造函数。

    由于constructor属性定义在prototype对象上面,意味着可以被所有实例对象继承。

    constructor属性的作用,是分辨原型对象到底属于哪个构造函数。

    2.6 总结

    1.原型和原型链是JS实现继承的一种模型。

    2.原型链的形成是真正是靠__proto__ 而非prototype。

    3.常见问题

    访问对象原型的方法有哪些?

    4.解决方法

    获取实例对象obj的原型对象,有三种方法:

    1. obj.__proto__

    2. obj.constructor.prototype

    3. Object.getPrototypeOf(obj)

    上面三种方法之中,前两种都不是很可靠。最新的ES6标准规定,__proto__属性只有浏览器才需要部署,其他环境可以不部署。而obj.constructor.prototype在手动改变原型对象时,可能会失效。

    5.编码实战

    6.扩展思考

    1.Object.__proto__ === Function.prototype // true

    2.Function.__proto__ === Function.prototype // true

    3.Function.prototype.__proto__ === Object.prototype //true

    1.Object是函数对象,是通过new Function()创建,所以Object.__proto__指向Function.prototype。

    2.Function 也是对象函数,也是通过new Function()创建,所以Function.__proto__指向Function.prototype。

    3.Function.prototype是个函数对象,理论上其__proto__应该指向 Function.prototype,就是它自己,自己指向自己,没有意义。函数对象也是对象,给它设定根指向Object.prototype,Object.prototype.__proto__ === null,保证原型链能够正常结束。

    7.参考文献

    参考一:阮一峰:Javascript继承机制的设计思想

    参考二:zhangjiahao8961:JavaScript原型及原型链详解

    8.更多讨论

    JavaScript 对象的继承机制

    鸣谢

    感谢大家观看

    PPT链接

    澳门新葡8455最新网站,视频链接

    JS原型对象和原型链简介_腾讯视频


    今天的分享就到这里啦,欢迎大家点赞、转发、留言、拍砖~

    下期预告:简述JS面向对象编程,不见不散~

    本文由澳门新葡8455最新网站发布于Web前端,转载请注明出处:JS核心系列,JS原型链和访问对象原型的方法

    关键词:

上一篇:前端幼功进级,成效域链与闭包

下一篇:没有了