How to pass arbitrary arguments to a javascript constructor

Question

I'm trying to figure out how to call a constructor function with an arbitrary number of arguments (passing the arguments on from some other function call).

I have a set of base and derived objects in javascript. One of the methods on the base object is called makeNew() and its job is create a new object of the same type as whatever object it's called on and process all the same arguments as the normal constructor would on the new object. The point of this makeNew() method is that there are other methods that want to create a new object of the same type as the current object, but they won't know what type that is because it may be a type that inherits from the base class. Note, I don't want a whole clone of the current object, but rather a new object of the same type, but initialized with different initial arguments to the constructor.

The simple version of makeNew() is this:

set.prototype.makeNew = function() {
    return new this.constructor();
}

This works for creating an empty object of the same type as the current one because if it's an inherited object type, then this.constructor will be the inherited constructor and it will make the right type of object.

But, when I want to pass on arbitrary arguments to the constructor so normal constructor arguments can be passed to makeNew(), I can't figure out how to do it. I tried this:

set.prototype.makeNew = function() {
    return new this.constructor.apply(this, arguments);
}

But, that code gives me this error in Chrome:

Error: function apply() { [native code] } is not a constructor

Any idea how to pass on arbitrary arguments to a constructor function?

Answer 1

The only way I see it is that you'll have to create a method in-between to spread the array into arguments.

This method, for example, first creates the new object, and then uses apply to spread the array.

Function.prototype.construct = function(argArray) {
    var constr = this;
    var inst = Object.create(constr.prototype); //creates a new empty object
    constr.apply(inst, argArray); // triggers the constructor (as a function)
    return inst;
};

then you can use

return set.construct(array)

Read more (much more) at http://www.2ality.com/2011/08/spreading.html

Note: Object.create might now work on old browser. Use the polyfill from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create

Answer 2

If you can change the constructor, this way seems legit to me, it relies on the delicate differences between constructors, objects, and functions in javascript.

function set(arg1, arg2, arg3){
    // entered the constructor, `this` = new object (like using Object.create)
    if(arg1 instanceof Array){ //if arg1 is an array
        this.constructor.apply(this, arg1); //use apply to spread it
        // apply now refers to the constructor as a function
        // notice the reference to `this.constructor`. 
        // This is because `this` no longer refers to the function, 
        // but to the newly created object.
    }else{
        // the actual function.
        console.log(arg2);
    }
}
new set([1,2,3])

Now it's up to you to figure out how to make this work in prototypical inheritance... They way I see it, you'll have to copy this code in to every class. Or have it inherited:

function set(arg1, arg2, arg3){
    if(set.prototype.initCheck.call(this, arg1)){ //this will have to be copied to every inherited class...
        ///the actual constructor
    }
}
set.prototype.initCheck = function(arg1){
    if(arg1 instanceof Array){ //if arg1 is an array
        this.constructor.apply(this, arg1); //use apply to spread it
        return false;
    }
    return true;
}
new set([1,2,3])

Answer 3

Supplying an answer to my own question. The various discussion led me to a couple possible solution to this.

If you control all the objects involved, you can take all the active code out of the constructors and put it in an .init() method and follow that design pattern. Then, you can do this:

function set() {
    this.init.apply(arguments);
}

set.prototype.init = function() {
    // process all constructor arguments here
}

set.prototype.makeNew = function() {
    // create object of the same type as what we are
    // even if it's a derived object type
    var newSet = new this.constructor()

    // apply any constructor arguments
    newSet.init.apply(newSet, arguments);

    return newSet;
}

All derived classes would also have to follow the same .init() design pattern including calling the base class if they added or processed any constructor arguments themselves beyond just letting the base class handle the constructor arguments.

---

Actually, in cases where an empty constructor doesn't do much and doesn't have any issues being called twice, you can even do this:

function set() {
    // do whatever object initialization from arguments
    // that the object wants to do
}

set.prototype.makeNew = function() {
    // create object of the same type as what we are
    // even if it's a derived object type
    // first time called without any constructor arguments
    var newSet = new this.constructor();

    if (arguments.length) {
        // apply any constructor arguments
        // by simply calling the constructor again without "new"
        // and this time passing it the object we already made
        // and the arguments we have
        this.constructor.apply(newSet, arguments);
    }

    return newSet;
}