If the two different calling schemes you want to support are this:
sendMessage(type,url,method,json,retries,formData,cb)
and this:
sendMessage(type,url,method,json,retries,cb)
And, the callback argument is always required, then, you can do that like this:
function sendMessage(type,url,method,json,retries,formDataArg,cbArg) {
var cb = cbArg, formData = formDataArg;
// if we don't have a cb arg, then it must have been called with the
// shorter form that doesn't have formData
if (!cb) {
cb = formDataArg;
formData = null;
}
// continue rest of function using cb and formData as the symbols
// for the last two arguments
// ... other code here ...
}
As others have said, when you get this many arguments, it's often better to use a single options object to which you attach properties. Then it becomes a lot easier to make some of the arguments optional.
You may also find this useful:
How to overload functions in javascript?
FYI, there is also the way you might solve something like this in a harder typed language. You'd create a second function that takes the extra argument and move the implementation there. Then, the original function just becomes a shell that calls the new function with null for the new argument.
function sendMessage2(type,url,method,json,retries,formDataArg,cbArg) {
// full implementation here with all arguments, formDataArg may be null
}
// original function here, calling signature unchanged
function sendMessage(type,url,method,json,retries,cbArg) {
// call new implementation with arguments in the right place
return sendMessage2(type, url, method, json, retries, null, cbArg);
}
While this works and doesn't use overloading, it's kind of a one-time shot because you don't want to end up with sendMesage3, sendMessage4, etc... Probably sendMessage2 should use the options object which is a lot more extensible so you aren't forced into this again. Then, sometime later when you have more flexibility, you can switch the older code over to the options object and get rid of the whole two API scheme entirely.
That could look like this:
function sendMessageOptions(options, cb) {
// main code here that supports formData to send the message
// gets arguments from the options object
}
// original function here, calling signature unchanged
function sendMessage(type,url,method,json,retries,cbArg) {
// call new implementation with arguments in the right place
return sendMessageOptions({type: type, url: url: method: method, json: json: retries: retries});
}
Note, I left the callback out of the options object because this makes the function compatible with the typical async calling convention and makes inline callbacks for the caller cleaner to code.
