Javascript Overloading With A Callback

Following the pattern recommended in this question, where we have something akin to: function foo(a, b, opts) { } foo(1, 2, {'method':'add'}); foo(3, 4, {'test':'equals', 'bar':'

Solution 1:

So basically you want to accept a variable number of arguments, followed by a callback as the last one? Something similar to how PHP's array_udiff works?

This is fairly simple:

functionfoo() {
    var args = [], l = arguments.length, i;
    for( i=0; i<l; i++) args[i] = arguments[i];

    var callback = args.pop();
    // now you have your variable number of arguments as an array `args`// and your callback that was the last parameter.
}

Solution 2:

I'd say just use the arguments object:

functionfoo(a, b) {
    // Do stuff// Done stuffvar alength = arguments.length;

    // If more than 2 arguments and last argument is a functionif(alength > 2 && typeofarguments[alength - 1] === 'function')
        arguments[alength - 1].call(this);
}

Solution 3:

You could do similar to .apply. (unlike .call)

functionfoo(args, cb) {}

foo(['a', 'b', 'c'], function() {} );

And if you need to, you could put them into variables using .shift:

functionfoo(args, cb) {
    var a = args.shift(),
        b = args.shift();
    // and so on...
}

Solution 4:

Ended up going with the following solution:

foo(args) {}

foo({"x":"add", "callback": function() {
  // do stuff
}});


foo({"x":"equals", "y":"tree", "callback": function() {
  // do stuff
}});

And then simply checking to see if the last arguments value is a function, ala @PaulP.R.O.'s solution above:

if((arguments.length > 1) && (typeofarguments[arguments.length - 1] === 'function')) {
  var callback = arguments[arguments.length - 1];
}