setting a default value to an undefined variable in javascript

Question

Ideally I want to be able to write something like:

function a( b ) {
    b.defaultVal( 1 );
    return b;
}

The intention of this is that if b is any defined value, b will remain as that value; but if b is undefined, then b will be set to the value specified in the parameter of defaultVal(), in this case 1.

Is this even possible?

Ive been toying about with something like this:

String.prototype.defaultVal=function(valOnUndefined){
    if(typeof this==='undefined'){
        return valOnUndefined;
    }else{
        return this;
    }
};

But I'm not having any success applying this kind of logic to any variable, particularly undefined variables.

Does anyone have any thoughts on this? Can it be done? Or am I barking up the wrong tree?

Solution 1

Well the most important thing to learn here is if a variable is undefined you, by default, do not have any methods available on it. So you need to use a method that can operate on the variable, but is not a member/method of that variable.

Try something like:

function defaultValue(myVar, defaultVal){
    if(typeof myVar === "undefined") myVar = defaultVal;
    return myVar;
}

What you're trying to do is the equivalent of this:

undefined.prototype.defaultValue = function(val) { }

...Which for obvious reasons, doesn't work.

Solution 2

Why not use the default operator:

function someF(b)
{
    b = b || 1;
    return b;
}

Job done! Here's more info about how it works.

Just as a side-note: your prototype won't work, because you're augmenting the String prototype, whereas if your variable is undefined, the String prototype doesn't exactly apply.

To be absolutely, super-duper-sure that you're only switching to the default value, when b really is undefined, you could do this:

var someF = (function(undefined)//get the real undefined value
{
    return function(b)
    {
        b = b === undefined ? 1 : b;
        return b;
    }
})(); // by not passing any arguments

Solution 3

While the two answers already provided are correct, the language has progressed since then. If your target browsers support it, you can use default function parameters like this:

function greetMe(greeting = "Hello", name = "World") {
  console.log(greeting + ", " + name + "!");
}

greetMe(); // prints "Hello, World!"
greetMe("Howdy", "Tiger"); // prints "Howdy, Tiger!"

Here are the MDN docs on default function parameters.

Comments

[Jimmery]

consider this: function someF(b){ b = b || true; return b; } this call: someF() would return true, but this call: someF(false) would return true - so this method is flawed when working with boolean values.

[Thor84no]

Kind of. This works for strings and various other objects, it does not however work for all objects, such as booleans and ints. 0, false, etc. will be overwritten by your "default". I wouldn't refer to || as "the default operator", as it really isn't. It's an inclusive OR, and you should probably be aware of the full effects of it before using it like this.

[Elias Van Ootegem]

I've updated my answer to avoid issues with falsy values being passed to the function causing unexpected return values. It's a but much, though. You could use function foo(b){ b = b === undefined : b;, too. But undefined can be reassigned (undefined = 1), which would break the function, that's why I'm using a closure