Optional argument first in JavaScript

Question

For the user's ease, I have a function that receives an optional argument first, before the required argument. For example:

ns.myFunction('optional arg', function(){
    //the required callback
});

I'm doing this rather than doing the following since the callback body could be long, and the user might forget to override the defaults to the optional arguments:

ns.myFunction(function(){
    //the required callback
}, 'optional arg');

Currently I'm doing this to check:

function myFunction(first, second) {

    //if second is undefined and first is a function
    if (typeof second === 'undefined' && typeof first === 'function') { 
        second = first;
    }
}

Questions

• Is this the right way?
• How would I do it so that it scales, especially if there were N optional arguments that are before the required argument?

Answer 1

This is not the right way because optional parameters are by convention always placed at the end. And you see a reason why: it is much easier to handle them. If the length of anonymous function is your concern, clients of your API should use function references or variables:

function callback1() { //...

var callback2 = function() {//...

myFunction(callbackX, optional);

The problem with escaping this can be solved with bind().

If you really want to go the path of multiple optional parameters and callback at the end, I can think of two ways: arguments object or wrapping all optional arguments in one options objects.

With arguments you can write:

var lastOptionalIndex = arguments.length - 2;
var callback = arguments[lastOptionalIndex + 1];  //required callback is always last
var optionalFirst = lastOptionalIndex >=0? arguments[0] : undefined;
var optionalSecond = lastOptionalIndex >=1? arguments[1] : undefined;
//...

See how ugly it is compared to:

function myFunction(callback, firstOptional, secondOptional //...

With options wrapper object you always have two arguments:

function myFunction(options, callback);

Where options is just an object:

{
  firstOptional: 1,
  secondOptional: 'foo'
  //...
}