javascript

Chapter 7: Anonymous Functions
The constructor in this code defines two privileged methods: getName() and setName() . Each method
is accessible outside the constructor and accesses the private name variable. Outside the Person
constructor, there is no way to access name . Since both methods are defined inside the constructor, they
are closures and have access to name through the scope chain. The private variable name is unique to
each instance of Person since the methods are being re - created each time the constructor is called. One
downside, however, is that you must use the constructor pattern to accomplish this result. As discussed
in Chapter 6 , the constructor pattern is flawed in that new methods are created for each instance. Using
static private variables to achieve privileged methods avoids this problem.
Static Private Variables
Privileged methods can also be created by using a private scope to define the private variables or
functions. The pattern is as follows:
(function(){
})();
//private variables and functions
var privateVariable = 10;
function privateFunction(){
return false;
}
//constructor
MyObject = function(){
};
//public and privileged methods
MyObject.prototype.publicMethod = function(){
privateVariable++;
return privateFunction();
};
In this pattern, a private scope is created to enclose the constructor and its methods. The private
variables and functions are defined first, followed by the constructor and the public methods. Public
methods are defined on the prototype, as in the typical prototype pattern. Note that this pattern defines
the constructor not by using a function declaration but instead by using a function expression. Function
declarations always create local functions, which is undesirable in this case. For this same reason, the
var keyword is not used with MyObject . Remember: initializing an undeclared variable always creates a
global variable, so MyObject becomes global and available outside the private scope.
195