构造函数属性：__ proto __。constructor vs prototype.constructor

Question

I am fairly new to Javascript and I am trying to dig deep and understand inheritance, constructor functions and prototype chain. So, I created a constructor function as such,

var a = function(){this.integer=1,this.float=1.0,this.string="one"}

Now, this function has a prototype.constructor property, a constructor property and a __proto__.constructor property.

I understand that the __proto__.constructor == the constructor function executed to create the function a. Also, the prototype.constructor is the function that is executed when I create an instance of 'a' using the new keyword.

However I don't understand what the third constructor property is for. Its equal to __proto__.constructor .

Also, b.__proto__.constructor !== Object.prototype.constructor , as I thought it would be. Why is that ?

Answer 1

a.__proto__ is the Function prototype (namely, Function.prototype ). It is the object from which all functions inherit function-specific methods like call , apply , bind , etc. It is true that a.__proto__.bind == a.bind .

a.__proto__.constructor is the Function constructor, ie, the function Function . The Function prototype has a reference to its associated constructor via the constructor property, as is always the default relationship between prototype object and constructor. (More on this "default relationship" in the next two paragraphs.)

Quite different is a.prototype -- in JavaScript, any function can be a constructor, ie, it may be called with new . Whenever a function is called with new , it creates a new object whose __proto__ is the function's prototype and points to the newly-created object via this . So inside a call to new a() it is true that this.__proto__ equals a.prototype . This prototype object is automatically created and stored in a.prototype at the moment the function a is defined.

a.prototype.constructor is equal to a , because the JavaScript internal routine that creates prototype objects for newly-defined functions (as specified in the previous paragraph) always gives that new prototype a constructor property that refers to the newly-defined function. To get really into the weeds, the relevant ECMAScript routine is 19.2.1.1.1, CreateDynamicFunction , which notes, "A prototype property is automatically created for every function created using CreateDynamicFunction, to provide for the possibility that the function will be used as a constructor."

a does not have its own constructor property, but it automatically inherits a.__proto__.constructor accessible as a.constructor , just as it inherits any other properties on its prototype parent (just like a.bind is really a.__proto__.bind ).

Finally, a.__proto__.constructor !== Object.prototype.constructor because Object.prototype is not a function object's prototypal parent, but instead Function.prototype is. It is instead true that a.__proto__.constructor === Function.prototype.constructor (and, more succinctly, a.__proto__ == Function.prototype and a.__proto__.constructor == Function ).