设置JavaScript函数的默认参数值

Question

我希望JavaScript函数具有可选参数,我将其设置为默认值,如果未定义该值,则使用该参数.在Ruby中你可以这样做:

def read_file(file, delete_after = false)
  # code
end

这是否适用于JavaScript？

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

Answer 1

从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';
  ...
}

Answer 2

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

这将delete_after赋值为delete_afterif if不是falsey值,否则分配字符串"my default here".有关更多详细信息,请查看Doug Crockford对该语言的调查,并查看操作员部分.

如果你想在一个通过这种方法行不通falsey值即false,null,undefined,0或"".如果您需要传递falsey值,则需要在Tom Ritter的答案中使用该方法.

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

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

Answer 3

我发现像这样简单的东西更加简洁和个性化.

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

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

Answer 4

在ECMAScript 6中,您实际上可以准确地写出您拥有的内容:

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

这将设置delete_after为false不存在或undefined.今天你可以使用像这样的ES6功能,如Babel等转发器.

有关更多信息,请参阅MDN文章.

Answer 5

默认参数值

使用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

Answer 6

该解决方案适用于js:

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

Answer 7

只需使用与undefined的显式比较.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}

Answer 8

作为更新...使用ECMAScript 6,您可以在函数参数声明中最终设置默认值,如下所示:

function f (x, y = 7, z = 42) {
  return x + y + z
}

f(1) === 50

正如 - http://es6-features.org/#DefaultParameterValues所引用的那样

Answer 9

作为一个长期的C++开发人员(Rookie to web development :)),当我第一次遇到这种情况时,我在函数定义中进行了参数赋值,就像在问题中提到的那样,如下所示.

function myfunc(a,b=10)

但请注意,它不能跨浏览器一致地工作.对我来说,它在我的桌面上使用chrome,但在android上没有使用chrome.如上所述,更安全的选择是 -

    function myfunc(a,b)
    {
    if (typeof(b)==='undefined') b = 10;
......
    }

对这个答案的意图不是重复相同的解决方案,其他人已经提到过,但是要告知函数定义中的参数赋值可能适用于某些浏览器,但不依赖于它.

Answer 10

在javascript中使用默认参数值时,我强烈建议极其谨慎.与高阶函数等结合使用时,它常常会造成错误forEach,map和reduce.例如,考虑以下代码行:

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

parseInt有一个可选的第二个参数function parseInt(s, [radix=10])但是parseInt有三个参数的map调用:(element,index和array).

我建议您将所需参数从可选/默认值参数中分离出来.如果您的函数需要1,2或3个必需参数,其默认值没有意义,请将它们作为函数的位置参数,任何可选参数都应该作为单个对象的命名属性.如果你的函数需要4个或更多,或许通过单个对象参数的属性提供所有参数更有意义.

在你的情况我建议你写你的DELETEFILE功能是这样的:(每个编辑 instead的评论)...

// unsafe
function read_file(fileName, deleteAfter=false) {
    if (deleteAfter) {
        console.log(`Reading and then deleting ${fileName}`);
    } else {
        console.log(`Just reading ${fileName}`);
    }
}

// better
function readFile(fileName, options) {
  const deleteAfter = !!(options && options.deleteAfter === true);
  read_file(fileName, deleteAfter);
}

console.log('unsafe...');
['log1.txt', 'log2.txt', 'log3.txt'].map(read_file);

console.log('better...');
['log1.txt', 'log2.txt', 'log3.txt'].map(readFile);

运行上面的代码段说明了未使用参数的默认参数值背后隐藏的危险.

Answer 11

对于有兴趣在Microsoft Edge中使用代码工作的任何人,请不要在函数参数中使用默认值.

function read_file(file, delete_after = false) {
    #code
}

在该示例中,Edge将抛出错误"Expecting")'"

绕过这个用途

function read_file(file, delete_after) {
  if(delete_after == undefined)
  {
    delete_after = false;
  }
  #code
}

截至2016年8月8日,这仍然是一个问题

Answer 12

按照语法

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

您可以定义形式参数的默认值。并使用typeof函数检查未定义的值。

Answer 13

function helloWorld(name, symbol = '!!!') {
    name = name || 'worlds';
    console.log('hello ' + name + symbol);
}

helloWorld(); // hello worlds!!!

helloWorld('john'); // hello john!!!

helloWorld('john', '(>.<)'); // hello john(>.<)

helloWorld('john', undefined); // hello john!!!

helloWorld(undefined, undefined); // hello worlds!!!

Answer 14

\r\n

\r\n

function throwIfNoValue() {\r\nthrow new Error(\'Missing argument\');\r\n}\r\nfunction foo(argValue = throwIfNoValue()) {\r\nreturn argValue ;\r\n}

\r\n

\r\n

\r\n

\n\n

这里 foo() 是一个函数，它有一个名为 argValue 的参数。如果我们在此处的函数调用中不传递任何内容，则将调用函数 throwIfNoValue() 并将返回结果分配给唯一的参数 argValue。这就是函数调用可以用作默认参数的方式。这使得代码更加简化和可读。

\n\n

这个例子取自这里

\n

Answer 15

如果您想使用最新的ECMA6语法，请使用它：

function myFunction(someValue = "This is DEFAULT!") {
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

它被称为default function parameters。如果没有传递值或未定义，它允许使用默认值初始化形式参数。 注意：它不适用于 Internet Explorer 或更旧的浏览器。

为了最大可能的兼容性使用这个：

function myFunction(someValue) {
  someValue = (someValue === undefined) ? "This is DEFAULT!" : someValue;
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

这两个函数具有完全相同的行为，因为这些示例中的每一个都依赖于以下事实：undefined如果在调用该函数时没有传递参数值，则参数变量将为。

Answer 16

如果您正在使用，ES6+您可以通过以下方式设置默认参数：

function test (foo = 1, bar = 2) {
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

如果您需要ES5语法，可以通过以下方式进行：

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;
  
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

在上面的语法中，OR使用了运算符。该OR运营商总是返回的第一个值，如果这可以转换为true如果没有它返回的右手边值。当函数在没有相应参数的情况下调用时，参数变量（bar在我们的示例中）undefined由 JS 引擎设置。undefined然后转换为 false，因此OR运算符返回值 0。

Answer 17

ES6：正如大多数答案中已经提到的，在 ES6 中，您可以简单地初始化一个参数和一个值。

ES5：大多数给定的答案对我来说都不够好，因为有时我可能不得不将0,null和等虚假值传递undefined给函数。要确定参数是否未定义，因为这是我传递的值而不是未定义，因为根本没有定义，我这样做：

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}

Answer 18

是的， ES6完全支持使用默认参数：

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

或者

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

但在ES5之前，你可以轻松地做到这一点：

function read_file(file, delete_after) {
  var df = delete_after || false;
  // Code
}

这意味着如果该值存在，则使用该值，否则，使用执行||相同操作的操作后的第二个值...

注意：如果你将一个值传递给ES6 的值，即使该值是假的，这之间也有很大的区别，它将被替换为新值，例如nullor ""... 但ES5 的值只有在只有传递的值时才会被替换是真的，那是因为工作方式||......