Private Variable

　　Any variable defined inside a function is considered private since it is inaccessable outside that function. This includes function arguments, local variables, and functions defined inside other functions.

　　A privileged method is a public method that has access to private variables and/or private functions. There are two ways to create privileged methods on objects. The first is to do so inside a constructor, as in this example:

 function MyObject(){
   var privateVariable = ;

   this.publicMethod = function(){
     privateVariable++;
     console.log(privateVariable);
   };
 }

 var object1 = new MyObject();
 object1.publicMethod();

 var object2 = new MyObject();
 object2.publicMethod();

　　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(){
     var privateVariable = 10;
     MyObject = function(){};
     MyObject.prototype.publicMethod = function(){
         privateVariable++;
         console.log(privateVariable);
     } ;
 })();

 var object1 = new MyObject();
 object1.publicMethod();

 var object2 = new MyObject();
 object2.publicMethod();

　　The main difference between this pattern and the pervious one is that private variables and functions are shared among instances.

　　Creating static private variables in this way allows for better code reuse through prototypes, although each instance doesn't have its own private variable. Ultimately, the decision to use instance or static private variables needs to be based on your individual requirements.

The Module Pattern

　　The module pattern, as described by Douglas Crockford, does the same for singletons. Singletons are objects of which there will only ever be one instance. Traditionally, singletons are created in JavaScript using object literal notation.

　　The module pattern augments the basic singleton to allow for private variables and privileged methods, taking the following format:

 var singleton = function(){
   var privateVariable = 10;
   function privateFunction(){
     return false;
   }

   return {
     publicProperty: true,
     publicMethod: function(){
       privateVariable++;
       return privateFunction();
     }
   };
 }();

 console.log(singleton.publicProperty);
 console.log(singleton.publicMethod());

　　The module pattern is useful for cases like this, when a single object must be created and initialized with some data and expose public methods that have access to private data.

The Module-Augmentation Pattern

　　Another take on the module pattern calls for the augmentation of the object before returning it. This pattern is useful when singleton object needs to be an instance of a particular type but must be augmented with additional properties and/or methods. Consider the following example:

 var singleton = function(){

   // private variables and functions
   var privateVariable = 10;
   function privateFunction(){
     return false;
   }

   // create object
   var object = new CustomType();

   // add privileged/public properties and methods
   object.publicProperty = true;
   object.publicMethod = function(){
     privateVariable++;
     return privateFunction();
   };

   // return the object
   return object;
 }();