Question

A nasty gotcha in javascript is forgetting to call new on a function meant to be instantiated, leading to this being bound to a different object (usually the global) instead of a fresh one. One workaround I read about is to check for it explicitly in the function-constructor using the following idiom:

function SomeConstructor(x, y, ...) {
    // check if `this` is created with new
    if ( !(this instanceof arguments.callee) )
        return new SomeConstructor(x, y, ...);
    // normal initialization code follows

Now new SomeConstructor(...) and SomeConstructor(...) are equivalent.

I’d like to simplify this by creating a wrapper function factory(fn) that does the first two lines and then delegates to the wrapped function fn. This would be used like:

SomeConstructor = factory(function (x, y, ...) {
    // normal initialization code follows
})

My first attempt was:

function factory(fn) {
  return function() {
    if ( !(this instanceof arguments.callee) ) {
      return new arguments.callee.apply(this, arguments);
    }
    fn.apply(this, arguments);
  }
}

but it fails with “Function.prototype.apply called on incompatible [object Object]”. The second attempt was:

function factory(fn) {
  return function() {
    if ( !(this instanceof arguments.callee) ) {
      var tmp = new arguments.callee();
      arguments.callee.apply(tmp, arguments);
      return tmp;
    }
    fn.apply(this, arguments);
  }
}

This sort of works but it may call the wrapped function twice: once with no arguments (to create a new instance) and once with the passed arguments for the actual initialization. Apparently this is fragile and inefficient but I can’t figure out a way to do it with a single call. Is this possible ?

EDIT: Based on bobince’s approach, here’s a similar one that does the trick:

function factory(init) {
    var run_init = true;
    function constr() {
        if ( !(this instanceof constr) ) {
            run_init = false;
            var tmp = new constr();
            run_init = true;
            init.apply(tmp, arguments);
            return tmp;
        }
    if (run_init)
        init.apply(this, arguments);
  }
  return constr;
}

As for whether this is something that should be encouraged or not, that’s debatable. I come from a Python background and I think of new as just noise (Java) or wart (Javascript), but I may be missing something.

Answer 1

You can pass a unique value into the constructor for the first call (with new) that signifies you don’t want the initialiser called yet:

var _NOINIT= {};
function factory(init) {
    function constr() {
        if (!(this instanceof constr)) {
            var inst= new constr(_NOINIT);
            init.apply(inst, arguments);
            return inst;
        }
        if (arguments[0]!==_NOINIT)
            init.apply(this, arguments);
    }
    return constr;
}

Note I’ve used a named inline function for the constructor because arguments.callee will be going away in ECMAScript Fifth Edition’s ‘strict’ mode.

However if you’re using a class factory, I suggest making the initialiser function a member of the class, rather than being passed in. That way, you can subclass a base class and have the subclass inherit the initialiser, which is normal behaviour in class-based languages. eg.:

Function.prototype.makeSubclass= function() {
    function constr() {
        var that= this;
        if (!(this instanceof constr))
            that= new constr(_NOINIT);
        if (arguments[0]!==_NOINIT && '_init' in that)
            that._init.apply(that, arguments);
        return that;
    }

    if (this!==Object)
        constr.prototype= new this(_NOINIT);
    return constr;
};

var Shape= Object.makeSubclass();
Shape.prototype._init= function(x, y) {
    this.x= x;
    this.y= y;
};

var Point= Shape.makeSubclass();
// inherits initialiser(x, y), as no need for anything else in there

var Circle= Shape.makeSubclass()
Circle.prototype._init= function(x, y, r) {
    Shape.prototype._init.call(this, x, y);
    this.r= r;
};

Of course you don’t have to put that into the Function prototype… it’s a matter of taste, really. As is allowing constructors without new.

Personally I prefer to throw an error rather than silently make it work, to try to discourage bare-constructor-calling, since this is a mistake elsewhere and may make the code slightly less clear.