Question

In John Resig’s post on Simple “Class” Instantiation in Javascript, he states:

“…if you have a frequently-accessed function (returning an object) that you want people to interact with, then it’s to your advantage to have the object properties be in the prototype chain and instantiate it. Here it is, in code:”

// Very fast
function User(){}
User.prototype = { /* Lots of properties ... */ };
// Very slow
function User(){
    return { /* Lots of properties */ };
}

I would like to apply this to a function like the following (which happens to live inside a “class” declaration)

//...
this.get_subscription = function(args)
{
    return {
        property_one: "value",
        property_two: {
            sub_prop: args.something
        }
    }
}

but have no idea where to put the args. If I do

this.get_subscription = function(args) {}
this.get_subscription.prototype = {
    property_one: "value"
    //...
}

it’ll say args are undefined. I’ve tried several variants, none of which work. How should I properly do this, in a way that doesn’t put args in the parent class’s scope?

Answer 1

Yes, that’s the drawback of the “everything-to-prototype”-idea: You don’t have access to the constructor arguments – they are only available inside the function body (exept you put them into a public property there). Everything that needs to use them does not belong to the prototype; you only will fill “default properties” on the prototype (usually methods that are common to all instances).

I think that you don’t need that anyway in here. The pattern is only useful for real constructor functions, which you don’t seem to have here (I then would expect this.Subscription). Also, the promised “performance boost” is negligible.

If you really would want to use it in here, it would be:

function Class() {
   this.Subscription = function(args) {
       this.propertyTwo = {
           subprop: args.something
       };
   };
   this.Subscription.prototype = {
       property_one: "value",
       property_two: {}
   };
}
// a method callable without the "new" operator:
Class.prototype.get_subscription = function(args) {
     return new this.Subscription(args);
}

usage:

var object = new Class();
var sub = new object.Subscription();
var sub2 = new object.Subscription();
// the promised boost is less memory usage for:
sub.propertyOne === object.Subscription.prototype.propertyOne === sub2.propertyOne;

Also care for Crockford's Prototypal inheritance – Issues with nested objects when you attempt to set/change/delete properties on the propertyTwo-Object(s).