Question

I’m just trying to understand Javascript a little deeper.

I created a ‘class’ gameData that I only want ONE of, doesn’t need a constructor, or instantiated.

So I created it like so…

var gameData = new function () {

    //May need this later 
    this.init = function () { 
    };

    this.storageAvailable = function () {
        if (typeof (Storage) !== "undefined") {
            return true;
        }
        else {
            return false;
        }
    };
}

Realizing that the ‘new’ keyword doesn’t allow it to be instantiated and makes it available LIKE a static class would be in C#.

Am I thinking of this correctly? As static?

Answer 1

No, it is not static because it still has a constructor property pointing to your “anonymous” function. In your example, you could use

var gameData2 = new (gameData.constructor)();

to reinstantiate a second object, so the “class” (instance actually) is not really “static”. You are basically leaking the constructor, and possibly the data that is bound to it. Also, a useless prototype object (gameData.constructor.prototype) does get created and is inserted in the prototype chain of gameData, which is not what you want.

Instead, you might use

• a single, simple object literal (as in Daff’s answer). That means you don’t have a constructor, no closure-scoped private variables (you have used none anyway) and no (custom) prototype.
• the (revealing) module pattern (as in jAndy’s answer). There you’d have an IIFE to create closure-scoped variables, and can return any kind of object.
• an actual constructor (“class”) that can be instantiated later (when needed), and yields the same singleton object always.

This is what the singleton pattern would look like:

function GameData() {
    if (this.constructor.singleton)
        return this.constructor.singleton;
    else
        this.constructor.singleton = this;

    // init:
    // * private vars
    // * public properties
    // ...
}
GameData.prototype.storageAvailable = function () {
    if (typeof (Storage) !== "undefined") {
        return true;
    }
    else {
        return false;
    }
};

var gameData = new GameData();
var gameData2 = new GameData();
gameData === gameData2 === GameData.singleton; // true

Yet, the prototype is quite useless because you have only one instance of GameData. It would only get interesting with inheritance.