__proto__与Constructor.prototype有何不同?

2020/10/28 23:42 · javascript ·  · 0评论
function Gadget(name, color)
{
   this.name = name;
   this.color = color;
}

Gadget.prototype.rating = 3

var newtoy = new Gadget("webcam", "black")

newtoy.constructor.prototype.constructor.prototype.constructor.prototype 

它总是返回等级为3的对象。

但是,如果我执行以下操作:

newtoy.__proto__.__proto__.__proto__

链条最终返回null

另外,在Internet Explorer中,如果没有__proto__属性,如何检查null

我最近一直在努力思考,最后想出了这个“地图”,我认为这可以使您对这个问题有更深入的了解

http://i.stack.imgur.com/KFzI3.png
在此处输入图片说明

我知道我不是第一个提出这个建议的人,但是找出它来发现它更有趣:-)。无论如何,之后我发现了另一个我认为基本相同的图表:

JavaScript对象布局

对我来说,最令人惊讶的事情是发现它Object.__proto__指向Function.prototype,而不是Object.prototype,但是我相信有充分的理由:-)

我也将图像中提到的代码粘贴到这里,以便于任何人想要对其进行测试。请注意,一些属性已添加到对象中,以使一些跳转后的位置变得容易知道:

Object.O1='';
Object.prototype.Op1='';

Function.F1 = '';
Function.prototype.Fp1 = '';

Cat = function(){};
Cat.C1 = '';
Cat.prototype.Cp1 = '';

mycat = new Cat();
o = {};

// EDITED: using console.dir now instead of console.log
console.dir(mycat);
console.dir(o);

constructor是由prototype功能对象属性指向的对象的预定义[[DontEnum]]属性,并且最初将指向功能对象本身。

__proto__ 等效于对象的内部[[Prototype]]属性,即其实际原型。

使用new运算符创建对象时,其内部[[Prototype]]属性将设置为构造函数的prototype属性所指向的对象

这意味着.constructor将评估为.__proto__.constructor,即用于创建对象的构造函数,并且据我们了解,protoype该函数属性用于设置对象的[[Prototype]]。

随之而来的.constructor.prototype.constructor.constructor(只要这些属性没有被覆盖);请参阅此处以获取更详细的说明。

如果__proto__可用,您可以遍历对象的实际原型链。在普通的ECMAScript3中无法执行此操作,因为JavaScript并非为深度继承层次结构而设计。

JavaScript的原型继承是基于__proto__属性的,即每个对象都继承其__proto__属性所引用的对象的内容

prototype属性仅对Function对象特别适用,并且仅在使用newoperator调用Functionas构造函数时才具有在这种情况下,创建的对象__proto__将被设置为构造函数Function.prototype

这意味着添加到Function.prototype将自动反映所有__proto__引用的对象Function.prototype

Function.prototype用另一个对象替换构造函数的对象将不会更新__proto__任何现有对象的属性。

请注意,__proto__不应直接访问属性,而应使用Object.getPrototypeOf(object)

为了回答第一个问题,我创建了一个定制的__proto__prototype参考,不幸的是stackoverflow不允许我添加“少于10个信誉”的图像。也许另一些时间。

[Edit]该图[[Prototype]]代替,__proto__因为ECMAScript规范是指内部对象。希望您能解决所有问题。

这里有一些提示可以帮助您理解该图:

red    = JavaScript Function constructor and its prototype
violet = JavaScript Object constructor and its prototype
green  = user-created objects
         (first created using Object constructor or object literal {},
          second using user-defined constructor function)
blue   = user-defined function and its prototype
         (when you create a function, two objects are created in memory:
          the function and its prototype)

请注意,constructor属性在创建的对象中不存在,但是是从原型继承的。

在此处输入图片说明

Object是夏娃,Function也是亚当,亚当(Function)使用其骨骼(Function.prototype)创建了夏娃(Object)。那谁创造了亚当(Function)?-JavaScript语言的发明者:-)。

根据utsaina的回答,我想添加更多有用的信息。

对我来说,最令人惊讶的事情是发现它Object.__proto__
指向
Function.prototype,而不是Object.prototype,但是我相信有充分的理由:-)

不应该这样。 Object.__proto__不应指向Object.prototype相反,实例Object oo.__proto__应指向Object.prototype

(请原谅我使用这些术语classinstanceJavaScript,但您知道的是:-)

我认为类Object本身是的一个实例Function,因此Object.__proto__ === Function.prototype因此:Object是夏娃,Function也是亚当,亚当(Function)使用其骨骼(Function.prototype)创建夏娃(Object)。

此外,即使类Function本身也是其自身的实例Function,即Function.__proto__ === Function.prototype,这也是为什么Function === Function.constructor

此外,常规类Cat是的实例Function,即Cat.__proto__ === Function.prototype

发生上述情况的原因是,实际上,当我们使用JavaScript创建类时,我们只是在创建一个函数,该函数应该是的实例FunctionObject而且Function很特殊,但它们仍然是班级,而是Cat普通班级。

作为一个因素,在Google Chrome JavaScript引擎中,以下4个参数:

  • Function.prototype
  • Function.__proto__
  • Object.__proto__
  • Cat.__proto__

它们都===(绝对等于)其他3个,其值是function Empty() {}

> Function.prototype
  function Empty() {}
> Function.__proto__
  function Empty() {}
> Object.__proto__
  function Empty() {}
> Cat.__proto__
  function Empty() {}
> Function.prototype === Function.__proto__
  true
> Function.__proto__ === Object.__proto__
  true
> Object.__proto__ === Cat.__proto__
  true

好。然后,谁创建了特殊function Empty() {}Function.prototype)?考虑一下:-)

我真的不知道为什么人们没有在您理解的实际问题上对您进行纠正。

这将使您更容易发现问题

因此,让我们看看发生了什么:

var newtoy = new Gadget("webcam", "black")

newtoy 
  .constructor //newtoy's constructor function is newtoy ( the function itself)
    .prototype // the function has a prototype property.( all functions has)
      .constructor // constructor here is a **property** (why ? becuase you just did `prototype.constructor`... see the dot ? )  ! it is not(!) the constructor function  !!! this is where your mess begins. it points back to the constructor function itself ( newtoy function)
         .prototype // so again we are at line 3 of this code snippet
            .constructor //same as line 4 ...
                .prototype 
                 rating = 3

太好了,现在让我们来看一下 __proto__

在此之前,请记住两件事__proto__

  1. 使用new运算符创建对象时,如果愿意,其内部[[Prototype]]/proto__属性将设置prototype为其constructor function或“创建者”property(1)

  2. 在JS中进行硬编码-:Object.prototype.__proto__is null

让我们将这两点称为“ bill

newtoy
     .__proto__ // When `newtoy` was created , Js put __proto__'s value equal to the value of the cunstructor's prototype value. which is `Gadget.prototype`.
       .__proto__ // Ok so now our starting point is `Gadget.prototype`. so  regarding "bill" who is the constructor function now? watch out !! it's a simple object ! a regular object ! prototype is a regular object!! so who is the constructor function of that object ? Right , it's the `function Object(){...}`.  Ok .( continuing "bill" ) does it has a `prototype` property ? sure. all function has. it's `Object.prototype`. just remember that when Gadget.prototype was created , it's internal `__proto__` was refered to `Object.prototype` becuase as "bill" says :"..will be set to the `prototype` property of   its `constructor function`"
          .__proto__ // Ok so now our satrting point is `Object.prototype`. STOP. read bullet 2.Object.prototype.__proto__ is null by definition. when Object.prototype ( as an object) was created , they SET THE __PROTO__ AS NULL HARDCODED

更好?

每个函数都会创建其原型。当我们使用该函数构造函数创建对象时,我对象__proto__属性将开始指向该函数的原型。

如果所有这些数字都是压倒性的,那么让我们看一下这些属性的含义。

STH.prototype

创建新函数时,将并行创建一个空对象,并使用[[Prototype]]将其链接到该函数要访问该对象,我们使用 prototype函数的属性。

function Gadget() {}
// in background, new object has been created
// we can access it with Gadget.prototype
// it looks somewhat like {constructor: Gadget}

请记住,prototype属性仅可用于功能。

构造函数

上面提到的原型对象除了-以外没有其他属性constructor此属性表示创建原型对象的函数。

var toy = new Gadget();

在创建Gadget函数时,我们还创建了一个对象,就像{constructor: Gadget}-一样Gadget.prototype作为constructor指创建的对象原型的函数,toy.constructor表示Gadget功能。我们写toy.constructor.prototype,我们得到{constructor: Gadget}了。

因此,存在一个恶性循环:您可以使用toy.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype,并且永远都是Gadget.prototype

toy
.constructor    // Gadget
.prototype    // {constructor: Gadget}
.constructor    // Gadget
.prototype    // {constructor: Gadget}
// ...

STH .__ proto__

虽然prototype是特定于函数的属性,__proto__但它位于中时可用于所有对象Object.prototype它指的是可以创建对象的函数原型。

[].__proto__ === Array.prototype
// true

({}).__proto === Object.prototype
// true

在这里toy.__proto__Gadget.prototype正如Gadget.prototype对象({})和对象是通过Object函数创建的一样(请参见上面的示例),我们得到Object.prototype这是JavaScript中的高级对象,__proto__只能指示null

toy
.__proto__    // Gadget.prototype (object looking like {constructor: Gadget})
.__proto__    // Object.prototype (topmost object in JS)
.__proto__    // null - Object.prototype is the end of any chain

简短的答案:__proto__是对prototype创建对象的构造函数属性的引用

JavaScript中的对象

JavaScript对象是集合的内置类型零个或多个属性属性是保存其他对象,原始值或函数的容器。

JavaScript中的构造函数

函数是常规对象([[Call]]以ECMA-262术语实现),具有可调用的附加功能,但在JavaScript中扮演另一个角色:如果通过调用它们,则它们将成为构造函数(对象的工厂)。new运算符因此,构造函数是其他语言类的粗略模拟。

每个JavaScript函数实际上都是Function内置函数对象的一个实例,该实例具有一个特殊的名称,该名称prototype用于实现基于原型的继承和共享属性。构造函数创建的每个对象都有对其构造函数值的隐式引用(称为原型__proto__prototype

构造函数prototype是一种用于构建对象蓝图,因为构造函数创建的每个对象都会继承对其的引用prototype

原型链

对象通过内部属性[[Prototype]]指定其原型__proto__两个对象之间的原型关系与继承有关:每个对象可以将另一个对象作为其原型。原型可能就是null价值。

通过__proto__属性连接的对象链称为原型链当引用对象中的属性时,该引用是在原型链中包含该名称的属性的第一个对象中遇到的属性。原型链的行为就像是单个对象一样。

看到这张图片(摘自这个博客):

proto.jpg

每当您尝试访问对象中的属性时,JavaScript都会在该对象中开始对其进行搜索,然后继续其原型,原型的原型等等,直到遇到该属性或是否__proto__拥有value为止null

这种使用原型链的继承通常称为委托,以避免与使用类链的其他语言混淆。

几乎所有对象都是的实例Object,因为Object.prototype它们在原型链中位于最后。Object.prototype不是Object因为Object.prototype.__proto__持有价值的一个实例null

您还可以使用如下null原型创建对象

var dict = Object.create(null);

这样的对象比文字对象是更好的映射(字典),这就是为什么有时将这种模式称为dict模式(字典的dict)的原因。

注意:使用创建的文字对象{}是的实例,Object因为({}).__proto__是对的引用Object.prototype

本文地址:http://javascript.askforanswer.com/__proto__yuconstructor-prototypeyouhebutong.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!