JavaScript_Succinctly

y simply memorizing the mechanics of how the chain hierarchy actually works. Refer
back to Chapter 1 if you need a refresher on how property values are resolved.
Why care about the prototype property?
You should care about the prototype property for four reasons.
Reason 1
The first reason is that the prototype property is used by the native constructor functions
(e.g., Object(), Array(), Function(), etc.) to allow constructor instances to inherit
properties and methods. It is the mechanism that JavaScript itself uses to allow object
instances to inherit properties and methods from the constructor function's prototype
property. If you want to understand JavaScript better, you need to understand how
JavaScript itself leverages the prototype object.
Reason 2
When creating user-defined constructor functions, you can orchestrate inheritance the
same way JavaScript native objects do. But first you have to learn how it works.
Reason 3
You might really dislike prototypal inheritance or prefer another pattern for object
inheritance, but the reality is that someday you might have to edit or manage someone
else's code who thought prototypal inheritance was the bee's knees. When this
happens, you should be aware of how prototypal inheritance works, as well as how it
can be replicated by developers who make use of custom constructor functions.
Reason 4
By using prototypal inheritance, you can create efficient object instances that all
leverage the same methods. As already mentioned, not all array objects, which are
instances of the Array() constructor, need their own join() methods. All instances
can leverage the same join() method because the method is stored in the prototype
chain.
Prototype is standard on all Function() instances
All functions are created from a Function() constructor, even if you do not directly
invoke the Function() constructor (e.g., var add = new Function('x', 'y',
'return x + z');) and instead use the literal notation (e.g., var add =
function(x,y){return x + z};).
When a function instance is created, it is always given a prototype property, which is
an empty object. In the following sample, we define a function called myFunction and
then access the prototype property which is simply an empty object.
121