One weakness of the inheritance patterns we have seen so far is that we get no privacy. All properties of an object are visible. We get no private variables and no private methods. Sometimes that doesn't matter, but sometimes it matters a lot. In frustration, some uninformed programmers have adopted a pattern of pretend privacy. If they have a property that they wish to make private, they give it an odd-looking name, with the hope that other users of the code will pretend that they cannot see the odd looking members. Fortunately, we have a much better alternative in an application of the module pattern.
We start by making a function that will produce objects. We will give it a name
that starts with a lowercase letter because it will not require the use of the
new prefix. The function contains four
It creates a new object. There are lots of ways to make an object. It can
make an object literal, or it can call a constructor function with the
new prefix, or it can use the
Object.create method to make a new
instance from an existing object, or it can call any function that returns
It optionally defines private instance variables and methods. These are
vars of the
It augments that new object with methods. Those methods will have
privileged access to the parameters and the
vars defined in the second step.
It returns that new object.
Here is a pseudocode template for a functional constructor (boldface text added for emphasis):