Question

current broken code: http://jsfiddle.net/9F52n/2/

What I’m trying to do: Learn how to define an object/function that behaves like a class, and be able to define subclasses, both static , and instantiatable (singleton in my example below).

Currently, my code below doesn’t work all that well. but, if the instantiatable class sand the static class were removed, you’ll see that I have the very basics of class creation down.

So, I guess my question is: what is the proper / most semantic way to define nested clases (singleton or otherwise) with the way I’ve defined TBR? (function(){...})(window)

var TBR = (function() {
    // define local copy of taco bell run
    var TBR = function() {
        return new TBR.fn.init();
    },
        message = "hello world!";

    TBR.fn = TBR.prototype = {
        constructor: TBR,
        init: function() {
            console.log("From TBR Constructor: " + message);
        }
    }

    var InstantiatableClass = function() {
        return new TBR.InstantiatableClass, fn.init();
    }

   InstantiatableClass.fn =InstantiatableClass.prototype = {
        constructor: TBR.InstantiatableClass,
        init: function() {
            console.log("from InstantiatableClass: " + message);
        }
    }

    this.staticClass = function() {
        var subMessage = "little world";
        init = function() {
            console.log("from staticClass: " + subMessage);
        }
    }
    // expose TBR to the window object
    window.TBR = TBR;

})(window);

Answer 1

var InstantiatableClass = function() {
    return new TBR.InstantiatableClass, fn.init();
}

InstantiatableClass.fn =InstantiatableClass.prototype ...

This does not work. Your InstantiatableClass local variable returns objects, the prototype will not get applied to them. Also, TBR.InstantiatableClass is defined nowhere. If that is what you wanted, you’d need to use

function InstantiatableClass() {
    // common constructor things
}
TBR.InstantiatableClass = InstantiatableClass; // assign a "static" property

Also, you should not [need to] overwrite the prototypes. Sure, the only difference is that constructor is enumerable now (as far as it is not forgotten), but the following would be much cleaner:

InstantiatableClass.fn = InstantiatableClass.prototype; // shortcut
InstantiatableClass.fn.init = function() { … };

---

Oh, you want something that works like jQuery. Imho you should not make the constructor (init) a property of the prototype – that is just very odd and I can’t see a reason to do so. I’d suggest this code:

window.TBR = (function() {
    function TbrConstructor() {
        …
    }
    function InstantiableConstructor() {
        …
    }

    // Now, the creator functions:
    function TBR() { return new TbrConstructor; }
    function Instantiable() { return new InstantiableConstructor; }

    // Now, overwrite the "prototype" properties - this is needed for
    // (new TbrConstructor) instanceof TBR === true
    // and also create those fn shortcuts
    TBR.fn = TBR.prototype = TbrConstructor.prototype;
    Instantiable.fn = Instantiable.prototype = InstantiableConstructor.prototype;

    // we might overwrite the "constructor" properties like
    TBR.fn.constructor = TBR;
    // but I don't see much sense in that - they also have no semantic value

    // At last, make Instantiable a property on the TBR function object:
    TBR.Instantiable = Instantiable;
    // and then only
    return TBR;
})();

// Usage

TBR(); // returns a TbrConstructor instance
TBR.Instantiable(); // returns a InstantiableConstructor instance