有没有办法在JavaScript的函数调用中提供命名参数？

我发现C＃中的命名参数功能在某些情况下非常有用。

calculateBMI(70, height: 175);

如果要在JavaScript中使用该怎么办？

我不想要的是：

myFunction({ param1: 70, param2: 175 });

function myFunction(params){
  // Check if params is an object
  // Check if the parameters I need are non-null
  // Blah blah
}

我已经使用过这种方法。还有另一种方法吗？

我可以使用任何库来做到这一点。

ES2015及更高版本

在ES2015中，可以使用参数解构来模拟命名参数。这将要求调用者传递一个对象，但是如果您还使用默认参数，则可以避免函数内部的所有检查：

myFunction({ param1 : 70, param2 : 175});

function myFunction({param1, param2}={}){
  // ...function body...
}

// Or with defaults, 
function myFunc({
  name = 'Default user',
  age = 'N/A'
}={}) {
  // ...function body...
}

ES5

有一种方法可以接近您想要的，但它基于Function.prototype.toString ^[ES5]的输出，该输出在某种程度上取决于实现，因此它可能与跨浏览器不兼容。

想法是从函数的字符串表示形式解析参数名称，以便您可以将对象的属性与相应的参数关联。

函数调用可能看起来像

func(a, b, {someArg: ..., someOtherArg: ...});

其中a和b是位置参数，最后一个参数是带有命名参数的对象。

例如：

var parameterfy = (function() {
    var pattern = /function[^(]*\(([^)]*)\)/;

    return function(func) {
        // fails horribly for parameterless functions ;)
        var args = func.toString().match(pattern)[1].split(/,\s*/);

        return function() {
            var named_params = arguments[arguments.length - 1];
            if (typeof named_params === 'object') {
                var params = [].slice.call(arguments, 0, -1);
                if (params.length < args.length) {
                    for (var i = params.length, l = args.length; i < l; i++) {
                        params.push(named_params[args[i]]);
                    }
                    return func.apply(this, params);
                }
            }
            return func.apply(null, arguments);
        };
    };
}());

您将用作：

var foo = parameterfy(function(a, b, c) {
    console.log('a is ' + a, ' | b is ' + b, ' | c is ' + c);     
});

foo(1, 2, 3); // a is 1  | b is 2  | c is 3
foo(1, {b:2, c:3}); // a is 1  | b is 2  | c is 3
foo(1, {c:3}); // a is 1  | b is undefined  | c is 3
foo({a: 1, c:3}); // a is 1  | b is undefined  | c is 3 

演示

这种方法有一些缺点（已经警告您！）：

• 如果最后一个参数是一个对象，则将其视为“命名参数对象”
• 您将始终获得与在函数中定义的参数一样多的参数，但是其中一些参数可能具有值undefined（这与根本没有值不同）。这意味着您不能arguments.length用来测试已传递了多少个参数。

除了拥有创建包装器的函数外，您还可以拥有一个接受函数和各种值作为参数的函数，例如

call(func, a, b, {posArg: ... });

甚至扩展，Function.prototype以便您可以执行以下操作：

foo.execute(a, b, {posArg: ...});

否 -对象方法是JavaScript的答案。只要您的函数期望一个对象而不是单独的参数，那么这没有问题。

这个问题在一段时间以来一直是我的宠儿。我是一位经验丰富的程序员，会讲多种语言。我最喜欢使用的一种语言是Python。Python支持命名参数，没有任何麻烦。...自从我开始使用Python（前一段时间）以来，一切都变得更加容易。我相信每种语言都应支持命名参数，但事实并非如此。

很多人说只使用“传递对象”技巧，以便您命名参数。

/**
 * My Function
 *
 * @param {Object} arg1 Named arguments
 */
function myFunc(arg1) { }

myFunc({ param1 : 70, param2 : 175});

效果很好，除了.....关于大多数IDE，我们很多开发人员都依赖我们IDE中的类型/参数提示。我个人使用PHP Storm（以及其他JetBrains IDE，例如python的PyCharm和Objective C的AppCode）

使用“传递对象”技巧的最大问题是，当您调用函数时，IDE会为您提供一个类型提示，仅此而已...我们应该如何知道应将哪些参数和类型输入到菜单中。 arg1对象？

所以...“传递对象”的技巧对我不起作用...实际上，在我不知道该函数需要什么参数之前，不得不先查看每个函数的docblock，这会引起更多的麻烦。.当然，对于当您维护现有代码时，但是编写新代码太可怕了。

好吧，这是我使用的技术。...现在，它可能存在一些问题，一些开发人员可能会告诉我我做错了，在这些事情上我持开放的态度...我一直乐于寻找完成任务的更好方法。因此，如果此技术存在问题，欢迎发表评论。

/**
 * My Function
 *
 * @param {string} arg1 Argument 1
 * @param {string} arg2 Argument 2
 */
function myFunc(arg1, arg2) { }

var arg1, arg2;
myFunc(arg1='Param1', arg2='Param2');

这样，我就两全其美了...新代码很容易编写，因为我的IDE为我提供了所有适当的参数提示...而且，尽管以后再维护代码，我一眼就能看到，不仅传递给函数的值，还有参数的名称。我看到的唯一开销是将参数名称声明为局部变量，以免污染全局名称空间。当然，这是额外的输入，但是与编写新代码或维护现有代码时查找docblock所花费的时间相比是微不足道的。

如果您想弄清楚每个参数是什么，而不仅仅是调用

someFunction(70, 115);

为什么不这样做以下

var width = 70, height = 115;
someFunction(width, height);

当然，这是额外的代码行，但是在可读性上胜出。

另一种方法是使用合适对象的属性，例如：

function plus(a,b) { return a+b; };

Plus = { a: function(x) { return { b: function(y) { return plus(x,y) }}}, 
         b: function(y) { return { a: function(x) { return plus(x,y) }}}};

sum = Plus.a(3).b(5);

当然，对于这个组成的示例，它毫无意义。但是如果函数看起来像

do_something(some_connection_handle, some_context_parameter, some_value)

可能会更有用。它也可以与“ parameterfy”思想相结合，以通用方式从现有功能中创建这样的对象。也就是说，它将为每个参数创建一个成员，该成员可以评估为该函数的部分评估版本。

这个想法当然与Schönfinkeling又名Currying有关。

还有另一种方式。如果要通过引用传递对象，则该对象的属性将出现在函数的本地范围内。我知道这适用于Safari（尚未检查其他浏览器），并且我不知道此功能是否有名称，但是以下示例说明了其用法。

尽管在实践中，我认为除了您已经使用的技术之外，它不提供任何功能价值，但从语义上讲它要干净一些。而且它仍然需要传递对象引用或对象文字。

function sum({ a:a, b:b}) {
    console.log(a+'+'+b);
    if(a==undefined) a=0;
    if(b==undefined) b=0;
    return (a+b);
}

// will work (returns 9 and 3 respectively)
console.log(sum({a:4,b:5}));
console.log(sum({a:3}));

// will not work (returns 0)
console.log(sum(4,5));
console.log(sum(4));

尝试使用Node-6.4.0（process.versions.v8 ='5.0.71.60'）和Node Chakracore-v7.0.0-pre8，然后再使用Chrome-52（V8 = 5.2.361.49），我注意到命名参数几乎是已实施，但该顺序仍然优先。我找不到ECMA标准所说的内容。

>function f(a=1, b=2){ console.log(`a=${a} + b=${b} = ${a+b}`) }

> f()
a=1 + b=2 = 3
> f(a=5)
a=5 + b=2 = 7
> f(a=7, b=10)
a=7 + b=10 = 17

但是需要订购！！这是标准行为吗？

> f(b=10)
a=10 + b=2 = 12

f以命名参数作为对象传递的调用函数

o = {height: 1, width: 5, ...}

基本上是f(...g(o))在我使用传播语法的地方调用它的组成，并且g是将对象值与其参数位置连接起来的“绑定”映射。

绑定映射恰好是缺少的成分，可以通过其键数组来表示：

// map 'height' to the first and 'width' to the second param
binding = ['height', 'width']

// take binding and arg object and return aray of args
withNamed = (bnd, o) => bnd.map(param => o[param])

// call f with named args via binding
f(...withNamed(binding, {hight: 1, width: 5}))

请注意三个分离的成分：函数，具有命名参数的对象和绑定。这种解耦为使用此结构提供了很大的灵活性，其中绑定可以在函数的定义中任意自定义，并在函数调用时任意扩展。

例如，你可能要缩写height，并width为h和w你的函数的定义中，使其更短和更清洁的，而你还是要为清楚起见以全名来称呼它：

// use short params
f = (h, w) => ...

// modify f to be called with named args
ff = o => f(...withNamed(['height', 'width'], o))

// now call with real more descriptive names
ff({height: 1, width: 5})

这种灵活性对于函数式编程也更为有用，在函数式编程中，函数可以随其原始参数名称丢失而随意转换。

来自Python，这困扰了我。我为节点编写了一个简单的包装器/代理，它将接受位置和关键字对象。

https://github.com/vinces1979/node-def/blob/master/README.md

与通常认为的相反，可以通过简单，简洁的编码约定在标准的老式JavaScript（仅适用于布尔参数）中实现命名参数，如下所示。

function f(p1=true, p2=false) {
    ...
}

f(!!"p1"==false, !!"p2"==true); // call f(p1=false, p2=true)

注意事项：

• 必须保留参数的顺序-但是该模式仍然有用，因为它可以清楚地表明哪个实际参数是针对哪个形式参数的，而无需grep获取功能签名或使用IDE。

• 这仅适用于布尔值。但是，我确信可以使用JavaScript的独特类型强制语义为其他类型开发类似的模式。