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

In addition to instance properties and properties of prototypes, JavaScript allows you to define
class properties (also known as static properties), properties of the type rather than of a
particular object instance. An example of a class property is Number.MAX_VALUE. This
property is a type-wide constant, and therefore is more logically located in the class
(constructor) rather than individual Number objects. But how are class properties
implemented?
Because constructors are functions and functions are objects, you can add properties to
constructors. Class properties are added this way. Though technically doing so adds an
instance property to a type‘s constructor, we‘ll still call it a class variable. Continuing our
example,
Robot.isMetallic = true;
defines a class property of the Robot object by adding an instance variable to the constructor.
It is important to remember that static properties exist in only one place, as members of
constructors. They are therefore accessed through the constructor rather than an instance of
the object.
As previously explained, static properties typically hold data or code that does not depend on
the contents of any particular instance. The toLowerCase() method of the String object could
not be a static method because the string it returns depends on the object on which it was
invoked. On the other hand, the PI property of the Math object (Math.PI) and the parse()
method of the String object (String.parse()) are perfect candidates, because they do not
depend on the value of any particular instance. You can see from the way they are accessed
that they are, in fact, static properties. The isMetallic property we just defined is accessed
similarly, as Robot.isMetallic.
Inheritance via the Prototype Chain
Inheritance in JavaScript is achieved through prototypes. It is clear that instances of a particular
object ―inherit‖ the code and data present in the constructor‘s prototype. But what we haven‘t
really seen so far is that it is also possible to derive a new object type from a type that already
exists. Instances of the new type inherit all the properties of their own type in addition to any
properties embodied in their parent.
As an example, we can define a new object type that inherits all the capabilities of our Robot
object by ―chaining‖ prototypes:
function UltraRobot(extraFeature)
{
}
if (extraFeature)
this.feature = extraFeature;
UltraRobot.prototype = new Robot();
UltraRobot.prototype.feature = "Radar";
The only new concept in this example is setting UltraRobot‘s prototype to a new instance of a
Robot object. Because of the way properties are resolved via prototypes, UltraRobot objects
―contain‖ the properties of the UltraRobot object as well as those of Robot:
var guard = new UltraRobot("Performs Calculus");