We learned (or already knew) that objects are the return of a function call (such as new Object();).

You can’t say it like that. That’s only true for your specific example right here. Also when using ‘new’ you’re technically not issuing a function call, but really instantiating an object.

I don’t want to nitpick, but that statement surely will confuse people.

var Singleton = {
one: 1,
two: function() {
return this.one + 1;
}
};

alert(Singleton.one);
alert(Singleton.two());

Singleton.prototype = {
// Public
}

Consider:

var singelton = (function() { function MyObj(…) { … }; …; var o = new MyObj(…); o.constructor = null; return o; })();

It will also inhibit the user from creating more instances from new some_object.constructor(…)

function provideSingleton (oSuper)
{
return (function()
{
var _instance = null;
return {
getInstance: function()
{
if(_instance == null) _instance = new oSuper();
return _instance;
}
};
})();
}

Firstly, what’s stopping someone creating another MyClass object by just calling new MyClass() as many times as they want?

Also, if I understand this right, the provideSingleton function returns an object which references the variable _private._instance in the containing function. But after the first time you call getInstance, this _private._instance var will be updated, never again equal to null, i.e. you can only call getInstance once.
I think the point your missing is there is only one variable _private.

(on another note, the way your initailizing this variable’s a bit wrong. This would be better
var _private = {};
_private._instance = null
)

You’re right about being able to create singleton’s dynamically, but i don’t think that’s possible in JavaScript

function provideSingleton ( oSuper ) {
var _private {_instance: null;}
return {
getInstance: function () {
if ( _private._instance == null ) _private._instance = new oSuper ();
return _private._instance;
}
};

To use it, just provide a JavaScript class definition to the function, and call it with the getInstance method, like this:

// rough and ready class def
function MyClass () {};
MyClass.prototype.instanceProperty = “instanceProperty”;
MyClass.prototype.instanceMethod = function () {
return this.instanceProperty;
};

var SingletonMyClass = provideSingleton ( MyClass );

var SingletonReference = SingeltonMyClass.getInstance();

SingletonMyClass.getInstance().instanceMethod() // returns ‘instance property’

SingeltonReference.instanceMethod() // returns ‘instance property’