1) Object.create() starts out by
creating an empty function called F.
I'm thinking that a function is a kind
of object. Where is this F object
being stored? Globally I guess.
No, it's stored on the local scope of the Object.create
function, each time you invoke Object.create
this function F
will be recreated.
You could even create a more memory-efficient implementation, by storing F
on a closure, and reuse it:
if (typeof Object.create !== "function") {
Object.create = (function () {
function F() {} // created only once
return function (o) {
F.prototype = o; // reused on each invocation
return new F();
};
})();
}
2) Next our oldObject, passed in as o,
becomes the prototype of function F.
Function (i.e., object) F now
"inherits" from our oldObject, in the
sense that name resolution will route
through it. Good, but I'm curious what
the default prototype is for an
object, Object? Is that also true for
a function-object?
All objects have an internal property that builds the prototype chain, this property is known as [[Prototype]]
, it's an internal property, although some implementations let you access to it, like mozilla, with the obj.__proto__
property.
The default [[Prototype]]
when you create a new object, i.e. var obj = {};
is Object.prototype
.
All functions have a prototype
property, this property is used when a function is used as a Constructor, invoked with the new
operator.
A new object instance it's created behind the scenes, and this object [[Prototype]]
is set to its Constructor's prototype
property.
3) Finally, F is instantiated and
returned, becoming our newObject. Is
the "new" operation strictly necessary
here? Doesn't F already provide what
we need, or is there a critical
difference between function-objects
and non-function-objects? Clearly it
won't be possible to have a
constructor function using this
technique.
Yes, the new
operator is essential in this method.
The new
operator is the only standard way to set the [[Prototype]]
internal property of an object, if you are curious about how it works, you can give a look to the [[Construct]]
internal operation.
What happens the next time
Object.create() is called? Is global
function F overwritten? Surely it is
not reused, because that would alter
previously configured objects. And
what happens if multiple threads call
Object.create(), is there any sort of
synchronization to prevent race
conditions on F?
The next time Object.create
is invoked, a new local F
function is instantiated only within the scope of the method call, you shouldn't worry about race conditions.
Note that this implementation hardly conforms the Object.create
described in the ECMAScript 5th Edition Specification, in that method, you could pass a property descriptor to initialize the object.
All browser vendors are implementing it (already available on Firefox 3.7 alphas, latest Wekit Nightly Builds and Chrome 5 Beta), so I would recommend you at least to check if a native implementation exist before overriding it.