JavaScript 2.0-The Complete Reference, Second ... - freecodingtutorial

object: because these are exactly the properties and methods of a generic Object!
Now that we‘ve explained the theoretical basis for JavaScript‘s object-oriented features, let‘s
see how it translates into implementation. If you‘re feeling a bit lost at this point, that‘s okay;
we‘ll reiterate the theory as we cover the concrete details.
Constructors
Object instances are created with constructors, which are basically special functions that
prepare new instances of an object for use. Every constructor contains an object prototype that
defines the code and data that each object instance has by default.
Note Before delving any deeper, some commentary regarding nomenclature is appropriate.
Because everything in JavaScript except primitive data and language constructs is an
object, the term ―object‖ is used quite often. It is important to differentiate between a type
of object, for example, the Array or String object, and an instance of an object, for
example, a particular variable containing a reference to an Array or String. A type of
object is defined by a particular constructor. All instances created with that constructor are
said to have the same ―type‖ or ―class‖ (to stretch the definition of class a bit). To keep
things clear, remember that a constructor and its prototype define a type of object, and
objects created with that constructor are instances of that type.
We‘ve seen numerous examples of object creation, for example,
var s = new String();
This line invokes the constructor for String objects, a function named String(). JavaScript
knows that this function is a constructor because it is called in conjunction with the new
operator.
We can define our own constructor by defining a function:
function Robot()
{
}
This function by itself does absolutely nothing. However, we can invoke it as a constructor just
like we did for String():
var guard = new Robot();
We have now created an instance of the Robot object. Obviously, this object is not particularly
useful. More information about object construction is necessary before we proceed.
Note Constructors don’t have to be named with an initial uppercase. However, doing so is
preferable because it makes the distinction clear between a constructor (initial uppercase)
that defines a type and an instance of a type (initial lowercase).
When a constructor is invoked, the interpreter allocates space for the new object and implicitly
passes the new object to the function. The constructor can access the object being created
using this, a special keyword that holds a reference to the new object. The reason the
interpreter makes this available is so the constructor can manipulate the object it is creating
easily. For example, it could be used to set a default value, so we can redefine
our constructor to reflect this ability:
function Robot()
{