我发现 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 对此的回答。如果您的函数需要一个对象而不是单独的参数，则这没有问题。
很多人说只需使用“传递对象”技巧即可命名参数。
/**
* 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 对象？
所以......“传递一个对象”技巧对我不起作用......它实际上会导致更多的麻烦，因为在我知道函数期望的参数之前必须查看每个函数的文档块......当然，它非常适合当您维护现有代码时，但编写新代码很糟糕。
嗯，这就是我使用的技术......现在，它可能存在一些问题，一些开发人员可能会告诉我我做错了，而我对这些事情持开放态度......我总是愿意寻找更好的方法来完成任务......所以，如果这个技术有问题，欢迎提出意见。
/**
* 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 为我提供了所有正确的参数提示……而且，在稍后维护代码的同时，我可以一目了然，不仅传递给函数的值，还有参数的名称。我看到的唯一开销是将参数名称声明为局部变量以防止污染全局命名空间。当然，这有点额外的输入，但与在编写新代码或维护现有代码时查找文档块所需的时间相比是微不足道的。
如果你想清楚每个参数是什么，而不是仅仅调用
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 aka Currying 有关。