I know Crockford has a famous object function for inheritance in JavaScript:
function object(o) {
function F() {}
F.prototype = o;
return new F();
}
But I am confused, after the line F.prototype = o, why he doesn't he reset the F.prototype's constructor, like this:
F.prototype.constructor = F
Isn't that common practice?
Isn't that common practice?
Only when your're creating subclasses (constructor functions with prototypes inheriting from other prototypes).
But that's not the purpose of this code, which basically Object.create. It takes the part of creating the object which inherits from another object, nothing else. The F constructor function is only intermediate and not supposed to be exposed.
F.prototype = o;why he doesn't he do
F.prototype.constructor = F?
Because that would change o itself. The aim is only to create a new object. Notice that it returns an instance of the intermediate constructor, not the constructor itself.
Where would the constructor be set (if needed)? On the new object that is instantiated by object:
function inherit(chd, par) {
chd.prototype = object(par.prototype);
chd.prototype.constructor = chd;
}
function Foo() {}
function Bar() {}
inherit(Foo, Bar);
/* Because of overwriting `constructor`: */
Foo.prototype.constructor === Foo
(new Foo).constructor === Foo
/* Because of the prototype chain: */
new Foo instanceof Bar // true, because
Foo.prototype instanceof Bar // true
Since you are using an instance of F as prototype object itself, there is no benefit in setting the constructor property.
For example:
function Foo() {}
function Bar() {}
Bar.prototype = object(Foo.prototype);
Bar.prototype.constructor = Bar;
So now Bar.prototype is an instance of F. We assigned the constructor property to that instance which would shadow the constructor property assigned to F.prototype. So why bother assigning it in the first place?
Generally speaking the constructor property has no significance in JavaScript, but it may be useful in your own code. I.e. your code might depend on the correct value of constructor. But in the object function, F is just a temporary constructor and object just replicates the functionality of Object.create, which is supported in newer browsers. I cannot think of a use case where you want a reference to F in your code.
