详解javascript中的Prototype、__proto__、Constructor、Object、Function

原创 tiangr  2016-12-13 19:49  阅读 143 次

1.在JS里,万物皆对象。方法(Function)是对象,方法的原型(Function.prototype)是对象。因此,它们都会具有对象共有的特点。
即:对象具有属性__proto__,可称为隐式原型,一个对象的隐式原型指向构造该对象的构造函数的原型,这也保证了实例能够访问在构造函数原型中定义的属性和方法。

2.方法(Function)
方法这个特殊的对象,除了和其他对象一样有上述_proto_属性之外,还有自己特有的属性——原型属性(prototype),这个属性是一个指针,指向一个对象,这个对象的用途就是包含所有实例共享的属性和方法(我们把这个对象叫做原型对象)。原型对象也有一个属性,叫做constructor,这个属性包含了一个指针,指回原构造函数。

所以:

1.构造函数Foo()
构造函数的原型属性Foo.prototype指向了原型对象,在原型对象里有共有的方法,所有构造函数声明的实例(这里是f1,f2)都可以共享这个方法。

2.原型对象Foo.prototype
Foo.prototype保存着实例共享的方法,有一个指针constructor指回构造函数。

3.实例
f1和f2是Foo这个对象的两个实例,这两个对象也有属性__proto__,指向构造函数的原型对象,这样子就可以像上面1所说的访问原型对象的所有方法啦。

即:

1.对象有属性__proto__,指向该对象的构造函数的原型对象。
2.方法除了有属性__proto__,还有属性prototype,prototype指向该方法的原型对象。

Function、Object:JS自带的函数对象。

prototype,每一个函数对象都有一个显示的prototype属性,它代表了对象的原型(Function.prototype函数对象是个例外,没有prototype属性)。

__proto__:每个对象都有一个名为__proto__的内部隐藏属性,指向于它所对应的原型对象(chrome、firefox中名称为__proto__,并且可以被访问到)。原型链正是基于__proto__才得以形成。

  1. var o1 = {};
  2. var o2 =new Object();
  3. function f1(){}
  4. var f2 = function(){}
  5. var f3 = new Function('str','console.log(str)');
  6. f3('aabb');   // aabb
  7. console.log('typeof Object:'+typeof Object);            //function
  8. console.log('typeof Function:'+typeof Function);        //function
  9. console.log('typeof o1:'+typeof o1);   //object
  10. console.log('typeof o2:'+typeof o2);   //object
  11. console.log('typeof f1:'+typeof f1);   //function
  12. console.log('typeof f2:'+typeof f2);   //function
  13. console.log('typeof f3:'+typeof f3);   //function
  • 通常我们认为o1、o2是对象,即普通对象;f1、f2、f3为函数。
  • 但是其实函数也是对象,是由Function构造的,
  • f3这种写法就跟对象的创建的写法一样。f1、f2最终也都像f3一样是有Function这个函数构造出来的
  • f1、f2、f3为函数对象,Function跟Object本身也是函数对象。

JS中每个对象(null除外)都和另一个对象相关联,通过以下例子跟内存效果图来分析Function、Object、Prototype、__proto__对象间的关系。

  1. function Animal(){
  2.    }
  3.    var  anim = new Animal();
  4.    console.log('***********Animal anim proto*****************');
  5.    console.log('typeof Animal.prototype:' +typeof Animal.prototype);  //object 
  6.    console.log('anim.__proto__===Animal.prototype:'+(anim.__proto__===Animal.prototype));  //true
  7.    console.log('Animal.__proto__===Function.prototype:'+(Animal.__proto__===Function.prototype));  //true
  8.    console.log('Animal.prototype.__proto__===Object.prototype:'+(Animal.prototype.__proto__===Object.prototype));  //true
  9.    console.log('***********Function proto*****************');
  10.    console.log('typeof Function.prototype:'+typeof Function.prototype);  //function
  11.    console.log('typeof Function.__proto__:'+typeof Function.__proto__);  //function
  12.    console.log('typeof Function.prototype.prototype:'+typeof Function.prototype.prototype); //undefined
  13.    console.log('typeof Function.prototype.__proto__:'+typeof Function.prototype.__proto__);   //object
  14.    console.log('Function.prototype===Function.__proto__:'+(Function.prototype===Function.__proto__)); //true
  15.    console.log('***********Object proto*****************');
  16.    console.log('typeof Object.prototype:'+typeof Object.prototype);  //object
  17.    console.log('typeof Object.__proto__:'+typeof Object.__proto__);  //function
  18.    console.log('Object.prototype.prototype:'+Object.prototype.prototype);  //undefied
  19.    console.log('Object.prototype.__proto__===null:'+(Object.prototype.__proto__===null));  //null
  20.    console.log('***********Function Object  proto关系*****************');
  21.    console.log('Function.prototype===Object.__proto__:'+(Function.prototype===Object.__proto__));   //true
  22.    console.log('Function.__proto__===Object.__proto__:'+(Function.__proto__===Object.__proto__));   //true
  23.    console.log('Function.prototype.__proto__===Object.prototype:'+(Function.prototype.__proto__===Object.prototype));   //true
  24.    /********************* 系统定义的对象Array、Date ****************************/
  25.    console.log('**************test Array、Date****************');
  26.    var array = new Array();
  27.    var date = new Date();
  28.    console.log('array.__proto__===Array.prototype:'+(array.__proto__===Array.prototype));   //true
  29.    console.log('Array.__proto__===Function.prototype:'+(Array.__proto__===Function.prototype));  //true
  30.    console.log('date.__proto__===Date.prototype:'+(date.__proto__===Date.prototype));    //true
  31.    console.log('Date.__proto__===Function.prototype:'+(Date.__proto__===Function.prototype));     //true

通过上图Function、Object、Prototype关系图中,可以得出一下几点:

  1. 所有对象,包括函数对象的原型链最终都指向了Object.prototype,而Object.prototype.__proto__===null,原型链至此结束。
  2. Animal.prototype是一个普通对象。
  3. Object是一个函数对象,也是Function构造的,Object.prototype是一个普通对象。
  4. Object.prototype.__type__指向null。
  5. Function.prototype是一个函数对象,前面说函数对象都有一个显示的prototype属性,但是Function.prototype却没有prototype属性,即Function.prototype.prototype===undefined,所有Function.prototype函数对象是一个特例,没有prototype属性。
  6. Object虽是Function构造的一个函数对象,但是Object.prototype没有指向Function.prototype,即Object.prototype!==Function.prototype。

Prototype跟Constructor关系介绍

在 JavaScript 中,每个函数对象都有名为“prototype”的属性(上面提到过Function.prototype函数对象是个例外,没有prototype属性),用于引用原型对象。此原型对象又有名为“constructor”的属性,它反过来引用函数本身。这是一种循环引用(i.e. Animal.prototype.constructor===Animal)。
通过以下例子跟内存效果图来分析Prototype、constructor间的关系。

  1. console.log('**************constructor****************');
  2. console.log('anim.constructor===Animal:'+(anim.constructor===Animal))    ;    //true
  3. console.log('Animal===Animal.prototype.constructor:'+(Animal===Animal.prototype.constructor))    ;    //true
  4. console.log('Animal.constructor===Function.prototype.constructor:'+(Animal.constructor===Function.prototype.constructor));   //true
  5. console.log('Function.prototype.constructor===Function:'+(Function.prototype.constructor===Function));    //true
  6. console.log('Function.constructor===Function.prototype.constructor:'+(Function.constructor===Function.prototype.constructor));    //true
  7. console.log('Object.prototype.constructor===Object:'+(Object.prototype.constructor===Object));    //true
  8. console.log('Object.constructor====Function:'+(Object.constructor===Function));    //true

prototype、constructor内存关系图(在Function、Object、Prototype关系图上加入constructor元素):

图中,红色箭头表示函数对象的原型的constructor所指向的对象。
注意Object.constructor===Function;本身Object就是Function函数构造出来的
如何查找一个对象的constructor,就是在该对象的原型链上寻找碰到的第一个constructor属性所指向的对象。

参考:
http://www.cnblogs.com/fool/category/264215.html (javascript 原理介绍)
http://www.libuchao.com/2012/05/14/prototypes-in-javascript/ (javascript 的原型对象 Prototype)
http://rockyuse.iteye.com/blog/1426510 (理解js中的原型链,prototype与__proto__的关系)

http://www.ruanyifeng.com/blog/2011/06/designing_ideas_of_inheritance_mechanism_in_javascript.html (javascript继承机制的设计思想)

特别提示:本站资源全部免费下载,因服务器需经费维护,文中部分外链点击后会进入广告,请耐心等待5秒即可跳过广告进入目标页面。如遇页面外链打不开或下载地址失效,您可以在评论中指出错误,或扫描页面底部二维码。
本文地址:http://www.tiangr.com/xiang-jie-javascript-prototype-proto-constructor-object-function.html
版权声明:本文为原创文章,版权归 tiangr 所有,欢迎分享本文,转载请保留出处!

发表评论


表情