Historically one JavaScript property that’s seen a lot of use (mostly due to its convenience) is that of __proto__ . It’s a quick-and-dirty way of accessing the original prototype property of the object’s constructor function. For example, the following is true:

"test".__proto__ === String.prototype // Another alternative, not using __proto__ // Only works when constructor isn't changed "test".constructor.prototype === String.prototype

This feature has been codified in the upcoming ECMAScript 3.1 specification as a new method: Object.getPrototypeOf(object) (and is implemented in the latest Firefox nightlies).

So how can we make use of this, now standardized, functionality?

instanceOf

If you wish you could implement your own version of the instanceof operator, using pure JavaScript.

function instanceOf(object, constructor) { while (object != null) { if (object == constructor.prototype) return true; object = Object.getPrototypeOf(object); } return false; } instanceOf("test", String); instanceOf(true, Boolean);

In this example we traverse up the prototype chain, checking each constructor along the way. It’s an effective method and allows for great expressiveness in our code.

Super Methods

We could use this function to call a super method, while doing some inheritance.

function Person(){} Person.prototype.kick = function(type){ alert(type + " kick!"); } function Norris(){} // Inherit properties from Person Norris.prototype = new Person(); Norris.prototype.kick = function(){ Object.getPrototypeOf(this).kick("Roundhouse"); };

In the above code we use Object.getPrototypeOf(this) to tap in to the original, inherited, kick method. Since we have since overridden the method we don’t have direct access to it, but using getPrototypeOf we can capture, and utilize, it again.

Cross-Browser Implementation

The obvious question now becomes: How do we begin using Object.getPrototypeOf today if most browsers don’t have it implemented yet? In the meantime we can use something like the following code for some form of compatibility:

if ( typeof Object.getPrototypeOf !== "function" ) { if ( typeof "test".__proto__ === "object" ) { Object.getPrototypeOf = function(object){ return object.__proto__; }; } else { Object.getPrototypeOf = function(object){ // May break if the constructor has been tampered with return object.constructor.prototype; }; } }

While it’s not 100% spot-on (since the .constructor property is mutable on any object – it’s fully possible that it could’ve been manipulated by the user at some point) the above code should serve as a “good enough” solution to tide you over until browsers have good ECMAScript 3.1 compatibility.

Why Object.getPrototypeOf?

A common question at this point (and one that’s sure to come up often as new features start to trickle in from ECMAScript 3.1): Why is the method Object.getPrototypeOf("test") and not "test".getPrototypeOf() – or even just a property, like __proto__ ? While having a method, or property, on every object would certainly be more convenient to use it ends up being impractical for generalized use.

For example, take the following case into consideration:

var obj = { getPrototypeOf: "blah" };

Any attempt to call its getPrototypeOf method would end in failure, forcing the developer to always have to fall back to using the generalized Object.getPrototypeOf . Since most uses of getPrototypeOf would be required to work in the general case the fallback would always have to be used. Thus it’s not necessary to include it as an extra property of every object.