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.
