REVEALING_MODULE_PATTERN.md

Revealing Module Pattern

This pattern is the same concept as the module pattern in that it focuses on public & private methods. The only difference is that the revealing module pattern was engineered as a way to ensure that all methods and variables are kept private until they are explicitly exposed; usually through an object literal returned by the closure from which it's defined. Personally, I like this approach for vanilla JavaScript as it puts a clear emphasis on both the intent of the developer and the module itself.

Advantages

• Cleaner approach for developers
• Supports private data
• Less clutter in the global namespace
• Localization of functions and variables through closures
• The syntax of our scripts are even more consistent
• Explicitly defined public methods and variables which lead to increased readability

Disadvantages

• Private methods are unaccessible.
• Private methods and functions lose extendability since they are unaccessible (see my comment in the previous bullet point).
• It's harder to patch public methods and variables that are referred to by something private.

Example

var MyModule = (function(window, undefined) {
    function myMethod() {
        console.log('my method');
    }

    function myOtherMethod() {
        console.log('my other method');
    }

    // explicitly return public methods when this object is instantiated
    return {
        someMethod: myMethod,
        someOtherMethod: myOtherMethod
    };
})(window);

//  example usage
MyModule.myMethod(); // undefined
MyModule.myOtherMethod(); // undefined
MyModule.someMethod(); // prints 'my method'
MyModule.someOtherMethod(); // prints 'my other method'

This pattern can also be implemented using a privately shared cache:

var MyModule = (function(window,undefined) {
    // this object is used to store private variables and methods across multiple instantiations
    var privates = {};

    function MyModule() {
        this.myMethod = function myMethod() {
            console.log('my method');
        };

        this.myOtherMethod = function myOtherMethod() {
            console.log('my other method');
        };
    }

    return MyModule;
})(window);

// example usage
var myMod = new MyModule();
myMod.myMethod(); // prints 'my method'
myMod.myOtherMethod(); // prints 'my other method'

---

Source:

• The Revealing Module Pattern
• The Module Pattern