Question

I cannot find anywhere in the JS spec where functions – when called with new should set the constructor property of their prototype to themselves.

Sure the spec says the Built-in constructors (Object, Array, String, &c) all set their prototype.constructor properties to themselves (i.e. Object.prototype.constructor = Object) BUT I can’t find anywhere that says this must/should happen for other constructors (seems it should be spelled out in the [[Construct]] section (13.2.2 [[Construct]]) yet it is not:

function F() {};
var obj = new F();
Object.getPrototypeOf(obj).constructor == F;  // non-standard??  I can't find where in spec

I ask because I see a lot of code ‘resetting’ the prototype.constructor property of a constructor ‘back’ to itself – yet this appears to be non-standard that this property points back to the constructor function in the first place?

function F() {};
F.prototype = new Parent();
F.prototype.constructor = F;  // 'reset' it cuz it changed! (according to spec it should never have been set?  Except in Object.prototype.

Can/should JS programmers rely on this non-standard(?) expectation that a constructor’s prototype.constructor property will point back to the constructor function itself if the prototype property is not set?

V8 certainly does this:

function F() {};
console.log(F.prototype.constructor === F); // true!  WHY???  not in spec?  Should be Object?

Hope that made vague sense – thanks!!
Mark

PS Due to their mutability I would only rely on instanceof instead of using the constructor property.

Answer 1

It is standard for all functions to have a .prototype property that points to an object with a .constructor property that points back to the function.

13.2 Creating Function objects

1) Create a new native ECMAScript object and let F be that object.

…

16) Let proto be the result of creating a new object as would be constructed by the expression new Object() where Object is the standard built-in constructor with that name.

17) Call the [[DefineOwnProperty]] internal method of proto with arguments "constructor", Property Descriptor {[[Value]]: F, { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}, and false.

18) Call the [[DefineOwnProperty]] internal method of F with arguments "prototype", Property Descriptor {[[Value]]: proto, { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}, and false.

So you can see F is the new function and proto is the prototype object. The proto gets a "constructor" property that points to F, and F gets a "prototype" property that points to the proto object