Utterly bewildered by JS 'arguments' peculiarity

Question

I have this call:

function del(Model, modelName, model_id, req, res, next, cb) {

    if(req.query.optimisticDelete){
        optimisticDelete(arguments);
    }
    else{
        pessimisticDelete(arguments);
    }
}

the problem of course, is that the arguments aren't passed correctly to the optimisticDelete and pessimisticDelete functions.

in an ideal JS world, this might work, but I can easily see why it doesn't.

But it doesn't take away from that fact that I just didn't want to type all the arguments out for each call, and in fact I wanted to omit the arguments in the del function signature also, so this would be the most ideal situation, although I need a reference to the req object, which I am now missing:

  function del() {

        if(req.query.optimisticDelete){
            optimisticDelete(arguments);
        }
        else{
            pessimisticDelete(arguments);
        }
    }

but of course, when arguments is passed, it does not seem to magically separate into separate arguments.

And also, this doesn't work either:

function del(Model, modelName, model_id, req, res, next, cb) {

    if(req.query.optimisticDelete){
        optimisticDelete(Array.prototype.slice.call(arguments));
    }
    else{
        pessimisticDelete(Array.prototype.slice.call(arguments));
    }
}

if you understand what I am trying to do, please let me know if it's possible and how,

Answer 1

You're calling optimisticDelete with a single argument, which is an arguments special object that contains all the arguments to the original call. If you want to spread them out, you need to use apply:

optimisticDelete.apply(null, arguments);

It's not necessary to convert arguments to an array first. MDN says:

You can also use arguments for the argsArray parameter. arguments is a local variable of a function. It can be used for all unspecified arguments of the called object. Thus, you do not have to know the arguments of the called object when you use the apply method. You can use arguments to pass all the arguments to the called object.

Answer 2

There are two problems. First, the arguments object is weird, but it's not that weird. Nothing magically turns into a parameter list across a simple function call. There is, however, Function.prototype.apply, which is ultimately what you want.

First however you'll want to turn arguments into a plain array:

var plainArgs = Array.prototype.slice.call(arguments);

Or, if you care about runtime efficiency:

var plainArgs = [];
for (var i = 0; i < arguments.length; ++i)
  plainArgs[i] = arguments[i];

(Note — this step may not be necessary, but passing the arguments object out of a function tends to make optimizers throw up their little hands and give up on your functions.)

(Another note — totally ignore this stuff about passing arguments to .apply() being bad. I'm wrong.)

With that out of the way, you can use .apply():

    optimisticDelete.apply(null, plainArgs);

The .apply() function expects its second argument to be an array. That array becomes the individual arguments to the function. The first argument to .apply() is the value you'd like this to take on in the function call; since you were calling optimisticDelete() "naked" in the original code, I passed null, but you can pass whatever you want.