Dhananjay Kumar

We talked about Prototype Pattern in previous posts. You can read them at below link.

Understanding Prototype Pattern in JavaScript

Understanding Prototype Pattern in JavaScript: Part # 2

Revealing Module Pattern allows us to achieve

• Singleton object
• Private Public behaviour of functions and properties in the object.

Let us consider the usual code we write. We also known as that functional spaghetti code.

var basicSalary;
 var salary;
 function CalculateSalaray(basicSalary) {
 salary = basicSalary * 10;
 }
 function PrintSalaray() {
 alert("Salary is " + salary);
 }

CalculateSalaray(200);
 PrintSalaray();

There is nothing wrong in above code snippet. However,

• It is hard to maintain when functionality grows
• It is hard to debug
• It is hard to test

In Revealing Module pattern we put all code inside a function represented by a variable. This is self-executed function.

Revealing module pattern allows us

• To achieve public private members
• To make code more readable

In this pattern we put all functions and variable inside the object. In above case everything would be encapsulated inside salary object. To make anything public we need to make them part of return statement.

var salaray = function () {

//Private
 var sal;
 function calculateSal(basesal) {
 sal = basesal*1000;
 }

function printSal(basesal) {
 calculateSal(basesal);
 console.log(sal);

 }

 //Public

return {
 PrintSalary: printSal

 };

}();

salaray.PrintSalary(2000);

 

In above code snippet we have two private functions. One of private function is exposed at public in return statement. Since object is wrapped as self-executable function hence it works as singleton. We can call public functions on object itself.

If we want to remove singleton then two steps need to be followed,

• Remove self-executable code
• Create new object using new operator.

So above object salary can be modified as below. Now it will have private public property but it would not act as singleton

var salaray = function () {

//Private
 var sal;
 function calculateSal(basesal) {
 sal = basesal*1000;
 }

function printSal(basesal) {
 calculateSal(basesal);
 console.log(sal);

 }

 //Public

return {
 PrintSalary: printSal

 };

};

var mysal = new salaray();
 mysal.PrintSalary(789);
 var mysal1 = new salaray();
 mysal.PrintSalary(100);

 

In above code salary object is not a singleton and having private and public functions. In many terms Revealing Module pattern can be considered as one of the best JavaScript pattern. Three advantages of using Revealing Module Pattern are as follows,

1. Achieve Singleton
2. Get Private –Public method behaviour
3. Better readability of code

I hope you find this post useful. Thanks for reading.