Simplest/Cleanest way to implement singleton in JavaScript?

0 votes
asked Sep 25, 2009 by jakub-arnold

What is the simplest/cleanest way to implement singleton pattern in JavaScript?

25 Answers

0 votes
answered Sep 25, 2009 by cms

I think the easiest way is to declare a simple object literal:

var myInstance = {
  method1: function () {
    // ...
  method2: function () {
    // ...

If you want private members on your singleton instance, you can do something like this:

var myInstance = (function() {
  var privateVar = '';

  function privateMethod () {
    // ...

  return { // public interface
    publicMethod1: function () {
      // all private members are accesible here
    publicMethod2: function () {

This is has been called the module pattern, it basically allows you to encapsulate private members on an object, by taking advantage of the use of closures.

0 votes
answered Sep 2, 2011 by skalee

I deprecate my answer, see my other one.

Usually module pattern (see CMS' answer) which is NOT singleton pattern is good enough. However one of the features of singleton is that its initialization is delayed till object is needed. Module pattern lacks this feature.

My proposition (CoffeeScript):

window.singleton = (initializer) ->
  instance = undefined
  () ->
    return instance unless instance is undefined
    instance = initializer()

Which compiled to this in JavaScript:

window.singleton = function(initializer) {
    var instance;
    instance = void 0;
    return function() {
        if (instance !== void 0) {
            return instance;
        return instance = initializer();

Then I can do following:

window.iAmSingleton = singleton(function() {
    /* This function should create and initialize singleton. */
    return {property1: 'value1', property2: 'value2'};

alert(window.iAmSingleton().property2); // "creating" will pop up; then "value2" will pop up
alert(window.iAmSingleton().property2); // "value2" will pop up but "creating" will not
window.iAmSingleton().property2 = 'new value';
alert(window.iAmSingleton().property2); // "new value" will pop up
0 votes
answered Sep 28, 2011 by stoyan

There is more than one ways to skin a cat :) Depending on your taste or specific need you can apply any of the proposed solutions. I personally go for CMS' first solution whenever possible (when you don't need privacy). Since the question was about the simplest and cleanest, that's the winner. Or even:

var myInstance = {}; // done!

This (quote from my blog) ...

var SingletonClass = new function() { 
    this.myFunction() { 
        //do stuff 
    this.instance = 1; 

doesn't make much sense (my blog example doesn't either) because it doesn't need any private vars, so it's pretty much the same as:

var SingletonClass = { 
    myFunction: function () { 
        //do stuff 
    instance: 1 
0 votes
answered Sep 30, 2011 by sebarmeli

I think the cleanest approach is something like:

var SingletonClass = (function(){
    function SingletonClass() {
        //do stuff
    var instance;
    return {
        getInstance: function(){
            if (instance == null) {
                instance = new SingletonClass();
                // Hide the constructor so the returned objected can't be new'd...
                instance.constructor = null;
            return instance;

Afterwards, you can invoke the function as

var test = SingletonClass.getInstance();
0 votes
answered Sep 4, 2012 by manav

What's wrong with this?

function Klass() {
   var instance = this;
   Klass = function () { return instance; }
0 votes
answered Sep 12, 2012 by zzzzbov

I'm not sure I agree with the module pattern being used as a replacement for a singleton pattern. I've often seen singletons used and abused in places where they're wholly unnecessary, and I'm sure the module pattern fills many gaps where programmers would otherwise use a singleton, however the module pattern is not a singleton.

module pattern:

var foo = (function () {
    "use strict";
    function aPrivateFunction() {}
    return { aPublicFunction: function () {...}, ... };

Everything initialized in the module pattern happens when Foo is declared. Additionally, the module pattern can be used to initialize a constructor, which could then be instantiated multiple times. While the module pattern is the right tool for many jobs, it's not equivalent to a singleton.

singleton pattern:

short form
var Foo = function () {
    "use strict";
    if (Foo._instance) {
        //this allows the constructor to be called multiple times
        //and refer to the same instance. Another option is to
        //throw an error.
        return Foo._instance;
    Foo._instance = this;
    //Foo initialization code
Foo.getInstance = function () {
    "use strict";
    return Foo._instance || new Foo();
long form, using module pattern
var Foo = (function () {
    "use strict";
    var instance; //prevent modification of "instance" variable
    function Singleton() {
        if (instance) {
            return instance;
        instance = this;
        //Singleton initialization code
    //instance accessor
    Singleton.getInstance = function () {
        return instance || new Singleton();
    return Singleton;

In both versions of the Singleton pattern that I've provided, the constructor itself can be used as the accessor:

var a,
a = new Foo(); //constructor initialization happens here
b = new Foo();
console.log(a === b); //true

If you don't feel comfortable using the constructor this way, you can throw an error in the if (instance) statement, and stick to using the long form:

var a,
a = Foo.getInstance(); //constructor initialization happens here
b = Foo.getInstance();
console.log(a === b); //true

I should also mention that the singleton pattern fits well with the implicit constructor function pattern:

function Foo() {
    if (Foo._instance) {
        return Foo._instance;
    //if the function wasn't called as a constructor,
    //call it as a constructor and return the result
    if (!(this instanceof Foo)) {
        return new Foo();
    Foo._instance = this;
var f = new Foo(); //calls Foo as a constructor
var f = Foo(); //also calls Foo as a constructor
0 votes
answered Sep 16, 2012 by talentedmrjones

@CMS and @zzzzBov have both given wonderful answers, but just to add my own interpretation based on my having moved into heavy node.js development from PHP/Zend Framework where singleton patterns were common.

The following, comment-documented code is based on the following requirements:

  • one and only one instance of the function object may be instantiated
  • the instance is not publicly available and may only be accessed through a public method
  • the constructor is not publicly available and may only be instantiated if there is not already an instance available
  • the declaration of the constructor must allow its prototype chain to be modified. This will allow the constructor to inherit from other prototypes, and offer "public" methods for the instance

My code is very similar to @zzzzBov's except I've added a prototype chain to the constructor and more comments that should help those coming from PHP or a similar language translate traditional OOP to Javascripts prototypical nature. It may not be the "simplest" but I believe it is the most proper.

// declare 'Singleton' as the returned value of a self-executing anonymous function
var Singleton = (function () {
    "use strict";
    // 'instance' and 'constructor' should not be availble in a "public" scope
    // here they are "private", thus available only within 
    // the scope of the self-executing anonymous function
    var _instance=null;
    var _constructor = function (name) { = name || 'default';

    // prototypes will be "public" methods available from the instance
    _constructor.prototype.getName = function () {

    // using the module pattern, return a static object
    // which essentially is a list of "public static" methods
    return {
        // because getInstance is defined within the same scope
        // it can access the "private" 'instance' and 'constructor' vars
        getInstance:function (name) {
            if (!_instance) {
                console.log('creating'); // this should only happen once
                _instance = new _constructor(name);
            return _instance;

})(); // self execute

// ensure 'instance' and 'constructor' are unavailable 
// outside the scope in which they were defined
// thus making them "private" and not "public"
console.log(typeof _instance); // undefined
console.log(typeof _constructor); // undefined

// assign instance to two different variables
var a = Singleton.getInstance('first');
var b = Singleton.getInstance('second'); // passing a name here does nothing because the single instance was already instantiated

// ensure 'a' and 'b' are truly equal
console.log(a === b); // true

console.log(a.getName()); // "first"
console.log(b.getName()); // also returns "first" because it's the same instance as 'a'

Note that technically, the self-executing anonymous function is itself a Singleton as demonstrated nicely in the code provided by @CMS. The only catch here is that it is not possible to modify the prototype chain of the constructor when the constructor itself is anonymous.

Keep in mind that to Javascript, the concepts of “public” and “private” do not apply as they do in PHP or Java. But we have achieved the same effect by leveraging Javascript’s rules of functional scope availability.

0 votes
answered Sep 29, 2012 by fred

I needed several singletons with:

  • lazy initialisation
  • initial parameters

and so this was what I came up with:

createSingleton ('a', 'add', [1, 2]);

function createSingleton (name, construct, args) {
    window[name] = {};
    window[construct].apply(window[name], args);
    window[construct] = null;

function add (a, b) {
    this.a = a;
    this.b = b;
    this.sum = a + b;
  • args must be Array for this to work so if you have empty variables, just pass in []

  • I used window object in the function but I could have passed in a parameter to create my own scope

  • name and construct parameters are only String for window[] to work but with some simple type-checking, and window.construct are also possible.

0 votes
answered Jan 9, 2013 by ncubica

Module pattern: in "more readable style". You can see easily which methods are publics and which ones are privates

var module = (function(_name){
   /*Local Methods & Values*/
   var _local = {
      name : _name,
      flags : {
        init : false

   function init(){
     _local.flags.init = true;

   function imaprivatemethod(){
     alert("hi im a private method");

   /*Public Methods & variables*/

   var $r = {}; //this object will hold all public methods.

   $r.methdo1 = function(){
       console.log("method1 call it");

   $r.method2 = function(){
      imaprivatemethod(); //calling private method

   $r.init = function(){
      inti(); //making init public in case you want to init manually and not automatically

   init(); //automatically calling init method

   return $r; //returning all publics methods


now you can use publics methods like

module.method2(); //-> I'm calling a private method over a public method alert("hi im a private method")

0 votes
answered Jan 23, 2013 by whill

I like to use a combination of the Singleton with the module pattern, init-time branching with a Global NS check, wrapped within a closure. In a case where the environment isn't going to change after the initialization of the singleton; the use of an immediately invoked object-literal to return a module full of utilities that will persist for some duration should be fine. I'm not passing any dependencies, just invoking the singletons within their own little world - the only goal being to: create a utilities module for event binding / unbinding (device orientation / orientation changes could also work in this case).

window.onload = ( function( _w ) {
            console.log.apply( console, ['it', 'is', 'on'] );
            ( {
                globalNS : function() {
                    var nameSpaces = ["utils", "eventUtils"],
                        nsLength = nameSpaces.length,
                        possibleNS = null;

                    for ( var i = 0; i < nsLength; i++ ) {
                        if ( !window[nameSpaces[i]] ) {
                            window[nameSpaces[i]] = this.utils;
                            break outerLoop;
                utils : {
                    addListener : null,
                    removeListener : null
                listenerTypes : {
                    addEvent : function( el, type, fn ) {
                        el.addEventListener( type, fn, false );
                    removeEvent : function( el, type, fn ) {
                        el.removeEventListener( type, fn, false );
                    attachEvent : function( el, type, fn ) {
                        el.attachEvent( 'on'+type, fn );
                    detatchEvent : function( el, type, fn ) {
                        el.detachEvent( 'on'+type, fn );
                buildUtils : function() {
                    if ( typeof window.addEventListener === 'function' ) {
                        this.utils.addListener = this.listenerTypes.addEvent;
                        this.utils.removeListener = this.listenerTypes.removeEvent;
                    } else {
                        this.utils.attachEvent = this.listenerTypes.attachEvent;
                        this.utils.removeListener = this.listenerTypes.detatchEvent;
                init : function() {
            } ).init();
        }( window ) );
Welcome to Q&A, where you can ask questions and receive answers from other members of the community.
Website Online Counter