Implementing Singleton object in JavaScript

I read a discussion in ExtJS forum about how to implement private methods (see here). It let me think what the guy wants is a modularization design, which is discussed in "A modular architecture based approach for Single Page Web application development". In order to implement the design, we need to use JavaScript closure concept. Here, I am going to further discuss a little about Singleton in JavaScript.

Singleton in Javascript is a little bit tough to be understood by Java developer because JavaScript does not use "class" to pursue OOP capability. Instead, it uses prototype to implement object inheriting.So, JavaScript has no "class". It only has Object. Each function is an Object in the memory.

Therefore, if you are just developing a project by yourself only, you can certainly implement your singleton as simple as below,

var singleton = {
   method1: function(){},
   method2: function(){}
}

However, if we want to have a more complex singleton object, which has private variable and method, we may employee below code,

var Singleton = (function() {
   //a private variable pointing to singleton object.
    var _instance = null; 
    
    //a private construction function, which is actually
    //the singleton object itself.
    function PrivateConstructor() {
        var publicVar = ``Hello '';
        this.publicMethod = function(name) {
            alert(publicVar + para);
        }
    }
    
    //This function return caller an object used
    //for getting singleton instance.
    return new function() {
        this.getInstance = function() {
            if (_instance == null) {
                _instance = new PrivateConstructor();
                _instance.constructor = null; //no more constructor!.
            }
            return _instance;
        }
    }
})();
var singletonInstance = Singleton.getInstance();
var singletonInstance2 = Singleton.getInstance();
alert(singletonInstance == singletonInstance2); //display true!

Or, this code give you true singleton too,

function singleton() {
 
  var instance = (function() {
  var privateVar = "Hello ";
  function privateMethod (param) {
    alert(privateVar + param);
  }
   return { // public interface
    publicMethod1: function (name) {
       privateMethod(name);
    }
   };
})();
singleton = function () { // re-define the function for subsequent calls
   return instance;
};
return new singleton; // call the new function
};
var singletonInstance = new singleton;
var singletonInstance2 = new singleton;
alert(singletonInstance == singletonInstance2); //display true!

In above examples, we used techniques like self-invoking, constructor function, javaScript closures etc.

Different from other language, JavaScript has no block scope. But, it has function scope. So, we use self-invoking function to add extra layer of scope.

Singpleton is useful to implement Factory design pattern. And, it can be useful if we want to implement function module as singleton.