JavaScript_Succinctly

Instances created from a constructor function are linked to the
constructor’s prototype property
While it’s only an object, prototype is special because the prototype chain links every
instance to its constructor function's prototype property. This means that any time an
object is created from a constructor function using the new keyword (or when an object
wrapper is created for a primitive value), it adds a hidden link between the object
instance created and the prototype property of the constructor function used to create it.
This link is known inside the instance as __proto__ (though it is only
exposed/supported via code in Firefox 2+, Safari, Chrome, and Android). JavaScript
wires this together in the background when a constructor function is invoked, and it’s
this link that allows the prototype chain to be, well, a chain. In the following sample, we
add a property to the native Array() constructor’s prototype, which we can then
access from an Array() instance using the __proto__ property set on that instance.
Sample: sample121.html
// This code only works in browsers that support __proto__ access.
Array.prototype.foo = 'foo';
var myArray = new Array();
console.log(myArray.__proto__.foo); // Logs foo, because
myArray.__proto__ = Array.prototype
Since accessing __proto__ is not part of the official ECMA standard, there is a more
universal way to trace the link from an object to the prototype object it inherits, and that
is by using the constructor property. This is demonstrated in the following sample.
Sample: sample122.html
Array.prototype.foo = 'foo'; // All instances of Array() now inherit a
foo property.
var myArray = new Array();
// Trace foo in a verbose way leveraging *.constructor.prototype
console.log(myArray.constructor.prototype.foo); // Logs foo.
// Or, of course, leverage the chain.
console.log(myArray.foo) // Logs foo.
// Uses prototype chain to find property at Array.prototype.foo
123