I’m deloping a huge project including a JS-Framework. Therefore it’s necessary to inherit classes. So imagine the following example:

We have a class Container and a inherited class FullFadeWindow. The Container-Class represents a Container-Widget that can be instantiated many times and that can contain data loaded per AJAX. The FullFadeWindow is a special window: its always on top and its covering the full screen (or browser window). So I want FullFadeWindow to be a singleton class, inheriting from Container, that is no singleton class.

This can’t be done using a pure static implementation (like Dan’s Log-Example), because of the prototype inheritance. Also the closures-solutions cannot be used this way, because all functions need to be declared in a local context which make prototype inheritance impossible. And because I cannot guarantee that nobody calls my constructor, if I’m using Dan’s first idea, the remaining possibility is MadKat’s one above. This way, we can simple make an existing class to a singleton one, we can use prototype inheritance, and we do not need to “milk” JS to brutally make this object based language to an complete object oriented one.

In addition, the way described in http://kaijaeger.com/articles/the-singleton-design-pattern-in-javascript.html (posted by Antony above) is also not usable in this scenario.

So, if you plan to use prototype inheritance (you know, like X.prototype = new Y()), you should consider MadKat’s solution.

Have fun,
Phil

http://kaijaeger.com/articles/the-singleton-design-pattern-in-javascript.html

^^

var MySingleton = (function()
{
var instance = null;

return function()
{
if (instance !== null)
{
return instance;
}

instance = this;

//init code
};
})();

var s1 = new MySingleton();
var s2 = new MySingleton();

s1 === s2; // true

I’m so glad that you have this code blog. I wasn’t able to find exactly what I was looking for, but I definitely got pointed in the right direction. Here’s my implementation of a singleton:

function Singleton() {
if (Singleton.instance == null) {
Singleton.instance = this;
Singleton.instance.initialize();
}
else {
// Do not want the extra object
delete this;
}

return Singleton.instance;
}

Singleton.prototype = {
instance: null,
initialize: function() {
// Actual constructor for your one instance
}
}

This way, I can call new Singleton() and get the same instance, without the need for getInstance().

var instance1 = new Singleton();
var instance2 = new Singleton();

alert(instance1 == instance2); // True

Personally, I’ve always preferred:

var CatNames = new function(){
var privateVar;

var privateMethod = function(){
…
};

this.publicMethod = function(){
…
};
};

Notice the “new function(){…}”. Still a little tacky but works quite well.