JavaScript_Succinctly

Providing a new object as the prototype property does not update the connection
between instances already created and the new prototype.
But remember, as I stated previously, you can update or add to the originally created
prototype object and those values remain connected to the first instance(s).
Sample: sample129.html
var Foo = function Foo() { };
Foo.prototype.x = 1;
var FooInstance = new Foo();
console.log(FooInstance.x); // Logs 1, as you think it would.
// Now let’s replace/override the prototype object with a new Object()
object.
Foo.prototype = { x: 2 };
console.log(FooInstance.x); // Logs 1. WHAT? Shouldn't it log 2 because
we just updated prototype?
/* FooInstance still references the same state of the prototype object
that was there when it was instantiated. */
// Create a new instance of Foo()
var NewFooInstance = new Foo();
// The new instance is now tied to the new prototype object value (i.e.
{x:2};).
console.log(NewFooInstance.x); // Logs 2.
The key idea to take away here is that an object’s prototype should not be replaced with
a new object once you start creating instances. Doing so will result in instances that
have a link to different prototypes.
User-defined constructors can leverage the same prototype
inheritance as native constructors
Hopefully at this point in the chapter, it is sinking in how JavaScript itself leverages the
prototype property for inheritance (e.g., Array.prototype). This same pattern can be
leveraged when creating non-native, user-defined constructor functions. In the following
128