还有另一种方法。如果通过引用传递对象，则该对象的属性将出现在函数的局部作用域中。我知道这适用于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));

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 

DEMO

这种方法有一些缺点(你已经被警告过了!):

如果最后一个参数是一个对象，它将被视为“命名参数对象” 您将始终获得与在函数中定义的相同数量的参数，但其中一些参数的值可能为undefined(这与完全没有值不同)。这意味着你不能使用参数。长度来测试传递了多少个参数。

与其让函数创建包装器，还可以让函数接受函数和各种值作为参数，例如

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

甚至扩展函数。这样你就可以做:

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

不——对象方法是JavaScript对此的答案。如果你的函数需要一个对象而不是单独的参数，这就没有问题。

很多人说使用“传递对象”技巧，这样你就有了命名参数。

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

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

这很有效，除了…当涉及到大多数IDE时，我们很多开发人员依赖于IDE中的类型/参数提示。我个人使用PhpStorm(以及其他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');

This way, I have the best of both worlds. New code is easy to write as my IDE gives me all the proper argument hints. And, while maintaining code later on, I can see at a glance, not only the value passed to the function, but also the name of the argument. The only overhead I see is declaring your argument names as local variables to keep from polluting the global namespace. Sure, it's a bit of extra typing, but it's trivial compared to the time it takes to look up docblocks while writing new code or maintaining existing code.

更新- 2022年

JavaScript现在可以在ES6中使用对象解构来实现类似于命名参数的功能。大多数较新的浏览器都可以使用此功能，请参阅浏览器支持

它是这样工作的:

// Define your function like this
function myFunc({arg1, arg2, arg3}) {
    // Function body
}

// Call your function like this
myFunc({arg1: "value1", arg2: "value2", arg3: "value3"})

// You can also have default values for arguments
function myFunc2({firstName, lastName, age = 21}) {
    // Function body
}

// And you can call it with or without an "age" argument
myFunc({firstName: "John", lastName: "Doe"}) // Age will be 21
myFunc({firstName: "Jane", lastName: "Doe", age: 22})

最好的部分是现在大多数IDE都支持这种语法，并且您可以获得良好的参数提示支持

打印稿

对于那些使用TypeScript的人，你可以使用这个语法做同样的事情

function myFunc(
    {firstName, lastName, age = 21}:
    {firstName: string, lastName: string, age?: number}
) {
    // Function body
}

或者，使用接口

interface Params {
    firstName: string
    lastName: string
    age?: number
}

function myFunc({firstName, lastName, age = 21}: Params) {
    // Function body
}

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

someFunction(70, 115);

做以下几点:

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

当然，这是额外的一行代码，但它在可读性上更胜一筹。

这确实是伪代码，但我相信它会起作用(我知道它在TypeScript中起作用;我将它用于JavaScript)。

// Target Function
const myFunc = (a=1,b=2,c=3) => {a+b+c}

// Goal usage:
myFunc(a=5, b=6) // 14
myFunc(c=0) // 3

// Set your defaults
const myFuncDefaults = {a:1, b:2, c:3};

// Override them with passed parameters
const myFuncParams = (params) => { return Object.assign(myFuncDefaults, params)}


// Use the overloaded dict as the input
const myFunc2 = (params) => {
  let {a, b, c} = myFuncParams(params);
  return myFunc(a, b, c)
}

// Usage:
myFunc({a:5, b:6}) // 14
myFunc({c:0}) // 3

// Written more succinctly:
const myFunc = (params) => {
  let {a,b,c} = Object.assign({a:1, b:2, c:3}, params)
  return a + b + c
}

不管它的价值是什么，TypeScript通过提示来实现这一点:

interface IParams {
  a: number;
  b: number;
  c: number;
}

const myFunc = (params: Partial<IParams>): number => {
  const default: IParams = {a:1, b:2, c:3};
  let {a, b, c} = Object.assign(default, params)
  return a + b + c
}