• Reported by Dave

This article demonstrates a nice technique for setting default values for function arguments in JavaScript. The basic form of the idiom is:

function foo(a, b, c) {
    var b = (b == null) ? "default" : b;
    var c = (c == null) ? 100 : c;
    ...
}

Within the body of a function, the argument b will receive the value of "default" if no corresponding value is passed to the function. This statement is repeated for each argument requiring a default value.

Not being one to leave well enough alone, I wanted to "improve" on this idea by creating a function to simplify the assigning of these defaults. Is this an improvement? You be the judge.

First, here is the function:

1.  function defaults(passed) {
2.      var pattern = /function[^(]*\(([^)]*)\)/;
3.      var args = passed.callee.toString().match(pattern)[1].split(/\s*,\s*/);
4.      var str = "", i = 1;
5.      for ( ; i < arguments.length; i++) {
6.          if (typeof passed[i-1] == "undefined") {
7.              str += args[i-1] + "=" + fix(arguments[i]) + ";";
8.          }
9.      }
10.     return str;
11.
12.     function fix(x) {
13.         if (typeof x == "string")
14.             return "'" + x.replace(/\'/g, "\\'") + "'";
15.         return x;
16.     }
17. }

And here is how to use it:

function foo(a, b, c) {
    eval(defaults(arguments, 1, 2, 3));

    alert(a); // defaults to 1
    alert(b); // defaults to 2
    alert(c); // defaults to 3
}

The defaults function requires the first argument to be the arguments object of the enclosing function (in this case, foo). The rest of the arguments are the default values for the corresponding arguments passed to foo.

The defaults function bears some explaining:

• The calling function (foo) is turned into a string, and its argument list is extracted (lines 2,3)
• The arguments passed to foo are examined (line 5). These are contained in the first argument passed to defaults, which is the arguments object of foo (confusing isn't it?)
• If any of these arguments are null, meaning no value was passed, the default value is assigned (lines 6,7)
• Assigning a variable at this point would make it local to the defaults function. We want it to be in the scope of foo. In order to do this, we need to return the assignment as a string then eval it (cue groaning from certain JavaScripters). For instance, if foo is called with no arguments, defaults will return: "a=1;b=2;c=3;". If it is called with one argument, defaults will return "b=2;c=3;", and so on
• The call to eval in foo effectively assigns the arguments with their default values
• The nested function fix ensures that strings are handled properly. Since defaults returns a string to be evaled, string assignments need to be wrapped in quotes and have any nested quotes escaped.

Some shortcomings, real or perceived:

• Only primitive types (numbers, booleans) and strings are handled
• Uses eval which some people dislike
• Might not be that much of an improvement over the "canonical" way of assigning defaults

It might not lend itself to some people's coding style or philosophy, but if you find yourself setting default values often in your functions, this technique offers a clean, consistent way of doing it.