从ES6/ES2015 开始，默认参数在语言规范中。

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

只是工作。

参考：默认参数 - MDN

如果未传递值或未定义，则默认函数参数允许使用默认值初始化形式参数。

您还可以通过解构模拟默认命名参数：

// 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
    ···
}

在 ES2015 之前，

有很多方法，但这是我的首选方法——它可以让你传入任何你想要的东西，包括 false 或 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
}

这就赋予delete_after的valuedelete_after，如果它不是一个falsey值，否则将字符串"my default here"。有关更多详细信息，请查看Doug Crockford 的语言调查并查看 Operators 部分。

如果您想传入错误值，即、、或false，则此方法不起作用。如果您需要传入 falsey值，则需要使用Tom Ritter's answer 中的方法。nullundefined0""

在处理函数的多个参数时，允许使用者在对象中传递参数参数，然后将这些值与包含函数默认值的对象合并通常很有用

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;
};

使用

// 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" }); 

我发现像这样简单的东西个人更简洁和可读。

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

function myFunc(x) {
  x = pick(x, 'my default');
} 

在 ECMAScript 6 中，您实际上将能够准确地编写您所拥有的内容：

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

如果它不存在，这将设置delete_after为false或undefined。您可以使用ES6的功能，比如这一个今天transpilers如巴贝尔。

有关更多信息，请参阅 MDN 文章。

默认参数值

使用 ES6，您可以执行JavaScript与为函数参数设置默认值相关的最常见的习惯用法之一。我们多年来这样做的方式应该看起来很熟悉：

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

这种模式最常用，但当我们传递像这样的值时很危险

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

为什么？因为0 is falsy, 所以x || 11 results in 11, 不是直接传入 0. 为了解决这个问题，有些人会像这样更详细地编写检查：

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

我们现在可以检查添加的一个很好的有用的语法，ES6以简化将默认值分配给缺失参数的过程：

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在函数声明中更像是x !== undefined ? x : 11比更常见的习语x || 11

默认值表达式

Function默认值可以不仅仅是像 31 这样的简单值；它们可以是任何有效的表达式，甚至是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

如您所见，默认值表达式是惰性求值的，这意味着它们仅在需要时才运行——也就是说，当参数的参数被省略或未定义时。

默认值表达式甚至可以是内联函数表达式调用——通常称为立即调用函数表达式(IIFE)：

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