JavaScript singleton class

var User = function () {
  this.username = "";
  this.password = "";
  this.login = function () {
    return true;
  }
}

// -----------------------------------------------------------------------------
// Create an instance of the User class, storing it in the same variable used to
// define the class initially. The original class has now been removed from the
// code, leaving only the single object instance of it
// -----------------------------------------------------------------------------

User = new User();

// -----------------------------------------------------------------------------
// Example method call on the single instance of User
// -----------------------------------------------------------------------------

User.login();

// -----------------------------------------------------------------------------
// Example of a self-instantiating class
// -----------------------------------------------------------------------------

var Inbox = new function () {
  this.messageCount = 0;
  this.refresh = function () {
    return true;
  }
  }();

// -----------------------------------------------------------------------------
// The new keyword and braces force the function to immediately execute,
// meaning the Inbox variable now contains the single object instance, not the 
// class. Example method call on the single instance of Inbox.
// -----------------------------------------------------------------------------

Inbox.refresh();

// =============================================================

/**
 * The Singleton Pattern
 *
 * The Singleton pattern is thus known because it restricts instantiation of a
 * class to a single object. Classically, the Singleton pattern can be
 * implemented by creating a class with a method that creates a new instance
 * of the class if one doesn't exist. In the event of an instance already
 * existing, it simply returns a reference to that object.
 *
 * Singletons differ from static classes (or objects) as we can delay their
 * initialization, generally because they require some information that may
 * not be available during initialization time. They don't provide a way for
 * code that is unaware of a previous reference to them to easily retrieve
 * them. This is because it is neither the object or "class" that's returned
 * by a Singleton, it's a structure. Think of how closured variables aren't
 * actually closures - the function scope that provides the closure is the
 * closure.
 *
 * In JavaScript, Singletons serve as a shared resource namespace which
 * isolate implementation code from the global namespace so as to provide a
 * single point of access for functions.
 *
 * We can implement a Singleton as follows:
 *
 * http://addyosmani.com/resources/essentialjsdesignpatterns/book/
 */
var mySingleton = (function () {
  'use strict';

  // Instance stores a reference to the Singleton
  var instance;

  function init() {

    //
    // Singleton
    //

    // private methods and variables
    function privateMethod() {
      console.log('I am private');
    }

    var privateVariable = 'Im also private';

    var privateRandomNumber = Math.random();

    return {

      // Public methods and variables
      publicMethod: function () {
        console.log('The public can see me!');
      },

      publicProperty: 'I am also public',

      getRandomNumber: function () {
        return privateRandomNumber;
      }

    };

  }

  return {

    // Get the Singleton instance if one exists
    // or create one if it doesn't
    getInstance: function () {

      if (!instance) {
        instance = init();
      }

      return instance;
    }

  };

})();

var myBadSingleton = (function () {

  // Instance stores a reference to the Singleton
  var instance;

  function init() {

    // Singleton

    var privateRandomNumber = Math.random();

    return {

      getRandomNumber: function () {
        return privateRandomNumber;
      }

    };

  }

  return {

    // Always create a new Singleton instance
    getInstance: function () {
      instance = init();

      return instance;
    }

  };

})();


//
// Usage
//


var singleA = mySingleton.getInstance();
var singleB = mySingleton.getInstance();
console.log(singleA.getRandomNumber() === singleB.getRandomNumber()); // true

var badSingleA = myBadSingleton.getInstance();
var badSingleB = myBadSingleton.getInstance();
console.log(badSingleA.getRandomNumber() !== badSingleB.getRandomNumber()); // true


// Note: as we are working with random numbers, there is a
// mathematical possibility both numbers will be the same,
// however unlikely. The above example should otherwise still
// be valid.


mySingleton.getInstance = function () {
  'use strict';

  if (this._instance === null) {
    if (isFoo()) {
      this._instance = new FooSingleton();
    }
    else {
      this._instance = new BasicSingleton();
    }
  }
  return this._instance;
};