Just a comment about JavaScript object types. I think it’s a bit misleading to classify these types as Singleton/Custom. Rather I would say – would you like an object with a static vs instantiable? MyObject = function(){}; roughly amounts to the same thing as MyObject = {}; – This difference is when you can create an instance of the function object. Let’s look at the difference:

MyClass = function(){
this.Name = “Dog”;
this.Sound = “Bark”;

var Owner = “Peter Gibbons”

var ChangeOwner = function(strNewOwner) { Owner = strNewOwner };

this.MakeSound = function() { return this.Sound; };
this.CheckPapers = function(strOwnerName) {
if (NO_ONE_IS_LOOKING && strOwnerName !== Owner) ChangeOwner(strOwnerName);
return Owner;
};
};

MyClass.prototype.PutDown = function() { return “Killed ” + this.Name; };
MyClass.Kill = function(oAnimal) { oAnimal.PutDown(); };

vs

MyStaticClass = {
Name: “Dog”,
Sound: “Bark”,
Owner: “Frank Wallace”,
ChangeOwner: function(strNewOwner) { this.Owner = strNewOwner },
MakeSound: function() { return this.Sound; },
…….
};

In OOP terms we have basically:

public class MyObject {} vs public static class MyObject{}

One requires a constructor (the function object) and one cannot be instantiated at all but can only be accessed statically. With a function object when you call var myObj = new MyClass(); you now get an instance of the object MyClass and the MyClass function is executed as the constructor.

Instantiable objects, like in most OOP worlds, do not prevent you from accessing or working with them in a static way. In our example MyClass has the static method Kill. You do not need to create an instance of MyClass to call the Kill method. But you will also notice that MyClass has a prototyped method defined. This means that this method will be a part of any new instance you create. Call it a class method.

Also notice the use of “var” within MyClass. The use of a constructor allows us to create private variables and methods that are a part of the instance. In addition we can expose public methods through the constructor that have access to this local variable scope – as demonstrated above.

Here’s the “Singleton” distinction. The Singleton pattern does not directly apply to static classes or static objects. The Singleton pattern is necessary when you have a class that you DO need to create one (or perhaps more) instance of but you want to ensure that multiple unnecessary instance are not created. Exemplified below.

Method A) Define the Object and instantiate it one time right away.
Page = new (function() {
// Constructor logic
// private vars
var a = “”;
// private methods
var b = function() {};
// public methods
this.c = function() {};
})();

And that’s it. Since Page is already an instance there is no need to go further. In this method it is NOT possible to create a new instance of Page, nor is it possible to access Page statically since it is now an active instance.

Method B) Define a static Object and use the Singleton method as a constructor of sorts

Page = {
instance: null,
_constructor: function() {
// private vars
// private methods
// public methods
return this;
},
GetInstance: function() { if (!Page.instance) Page.instance = Page._constructor(); return Page.instance; }
};

That’s kinda crappy cause you can bound up in a bunch of stuff

Method C) Define a function object and use the Singleton pattern

Page = function() {
// private vars
// private methods
// public methods
}

// Group prototype definitions
Page.prototype = {
methodName: function(){},
methodName2: function(){}
};

// Public method
Page.prototype.methodName = function() {};

// Static property
Page.instance = null;

// Static methods
Page.GetInstance = function() { if (!Page.instance) Page.instance = new Page(); return Page.instance; };

I like this the best – it’s just the cleanest. With this method I can make a new Page instance if I really want to by saying myExtraPage = new Page(); – But if I plan to access this class according to the singleton pattern I’ll say var myPage = Page.GetInstance(); – If the class has not been instantiated yet, then it will make sure to do that for me.

This is great – it gives me public and private methods and properties as well as public static methods and properties. I also find this method better lends itself to extensibility and reuse.

So to sum up – I would reserve the term Singleton when dealing with class objects (function objects) that you want only one instance of.