Question

What is the difference between these two ways of checking the arguments?

function foo(a, b) {
    this.a=a;
    this.b=b;
}

Using:

if (arguments.length === 1) {}

or

if (this.b !== undefined) {}

Answer 1

If you want to check mandatory arguments, I will use arguments.length as first step. If you want to check optional arguments, usually the pattern is:

function foo(a,b){
    this.a = a || "foo";
    // etc
}

Notice that this works only if the parameters can’t be “falsy” values (so, empty string, zero, null, undefined, false, NaN). For example, if you pass an empty string as a parameter, you will have foo. If you want to consider only undefined as value for considering a parameter optional then you have to do something like:

function foo(a){
    this.a = a === undefined ? "foo" : a;
    // etc
}

If you want to consider both null and undefined and optional parameter, you can have:

function foo(a){
    this.a = a == undefined ? "foo" : a;
    // etc
}

Of course, you can also use the operator typeof. For instance you want that a can be only a string:

function foo(a) {
    this.a = typeof a === "string" ? a : "";
    // etc
}

You can also force a to be always a string, in the worst scenario will be the string version of the non-string value given (undefined as well):

function foo(a) {
    this.a = String(a);
    // etc
}

More complex cases have some utility functions that makes all this check for you, where you said the arguments required, the optional, the default value, etc.