Set a default parameter value for a JavaScript function

From ES6/ES2015, default parameters are in the language specification.

function read_file(file, delete_after = false) {   // Code } 

just works.

Reference: Default Parameters - MDN

Default function parameters allow formal parameters to be initialized with default values if no value or undefined is passed.

You can also simulate default named parameters via destructuring:

// the `= {}` below lets you call the function without any parameters function myFor({ start = 5, end = 1, step = -1 } = {}) { // (A)     // Use the variables `start`, `end` and `step` here     ··· } 

Pre ES2015,

There are a lot of ways, but this is my preferred method — it lets you pass in anything you want, including false or null. (typeof null == "object")

function foo(a, b) {   a = typeof a !== 'undefined' ? a : 42;   b = typeof b !== 'undefined' ? b : 'default_b';   ... } 

function read_file(file, delete_after) {     delete_after = delete_after || "my default here";     //rest of code } 

This assigns to delete_after the value of delete_after if it is not a falsey value otherwise it assigns the string "my default here". For more detail, check out Doug Crockford's survey of the language and check out the section on Operators.

This approach does not work if you want to pass in a falsey value i.e. false, null, undefined, 0 or "". If you require falsey values to be passed in you would need to use the method in Tom Ritter's answer.

When dealing with a number of parameters to a function, it is often useful to allow the consumer to pass the parameter arguments in an object and then merge these values with an object that contains the default values for the function

function read_file(values) {     values = merge({          delete_after : "my default here"     }, values || {});      // rest of code }  // simple implementation based on $.extend() from jQuery function merge() {     var obj, name, copy,         target = arguments[0] || {},         i = 1,         length = arguments.length;      for (; i < length; i++) {         if ((obj = arguments[i]) != null) {             for (name in obj) {                 copy = obj[name];                  if (target === copy) {                     continue;                 }                 else if (copy !== undefined) {                     target[name] = copy;                 }             }         }     }      return target; }; 

to use

// will use the default delete_after value read_file({ file: "my file" });   // will override default delete_after value read_file({ file: "my file", delete_after: "my value" });  

I find something simple like this to be much more concise and readable personally.

function pick(arg, def) {    return (typeof arg == 'undefined' ? def : arg); }  function myFunc(x) {   x = pick(x, 'my default'); }  

In ECMAScript 6 you will actually be able to write exactly what you have:

function read_file(file, delete_after = false) {   // Code } 

This will set delete_after to false if it s not present or undefined. You can use ES6 features like this one today with transpilers such as Babel.

See the MDN article for more information.

Default Parameter Values

With ES6, you can do perhaps one of the most common idioms in JavaScript relates to setting a default value for a function parameter. The way we’ve done this for years should look quite familiar:

function foo(x,y) {  x = x || 11;  y = y || 31;  console.log( x + y ); } foo(); // 42 foo( 5, 6 ); // 11 foo( 5 ); // 36 foo( null, 6 ); // 17 

This pattern is most used, but is dangerous when we pass values like

foo(0, 42) foo( 0, 42 ); // 53 <-- Oops, not 42 

Why? Because the 0 is falsy, and so the x || 11 results in 11, not the directly passed in 0. To fix this gotcha, some people will instead write the check more verbosely like this:

function foo(x,y) {  x = (x !== undefined) ? x : 11;  y = (y !== undefined) ? y : 31;  console.log( x + y ); } foo( 0, 42 ); // 42 foo( undefined, 6 ); // 17 

we can now examine a nice helpful syntax added as of ES6 to streamline the assignment of default values to missing arguments:

function foo(x = 11, y = 31) {  console.log( x + y ); }  foo(); // 42 foo( 5, 6 ); // 11 foo( 0, 42 ); // 42 foo( 5 ); // 36 foo( 5, undefined ); // 36 <-- `undefined` is missing foo( 5, null ); // 5 <-- null coerces to `0` foo( undefined, 6 ); // 17 <-- `undefined` is missing foo( null, 6 ); // 6 <-- null coerces to `0` 

x = 11 in a function declaration is more like x !== undefined ? x : 11 than the much more common idiom x || 11

Default Value Expressions

Function default values can be more than just simple values like 31; they can be any valid expression, even a function call:

function bar(val) {  console.log( "bar called!" );  return y + val; } function foo(x = y + 3, z = bar( x )) {  console.log( x, z ); } var y = 5; foo(); // "bar called"  // 8 13 foo( 10 ); // "bar called"  // 10 15 y = 6; foo( undefined, 10 ); // 9 10 

As you can see, the default value expressions are lazily evaluated, meaning they’re only run if and when they’re needed — that is, when a parameter’s argument is omitted or is undefined.

A default value expression can even be an inline function expression call — commonly referred to as an Immediately Invoked Function Expression (IIFE):

function foo( x =  (function(v){ return v + 11; })( 31 ) ) {  console.log( x ); } foo(); // 42