Javascript 什么'；s表示函数使用'；参数'；对象

指示函数使用“arguments”对象的最佳方式是什么？
这显然是基于意见的，但有什么惯例吗？什么时候使用参数数组更好

一些例子：

// Function takes n arguments and makes them pretty.
function manyArgs() {
    for (var i = 0; i < arguments.length; i++)
    console.log(arguments[i]);
}

function manyArgs( /* n1 , n2, ... */ )

function manyArgs(n1 /*, n2, ... */ )

function manyArgs(argArray)

//函数接受n个参数并使它们变得漂亮。
函数manyArgs（）{
for（var i=0；i

我从不在JavaScript中使用可变参数。有很多更好的方法来构造代码。例如，我将重写您的代码，如下所示：

[1,2,3,4,5].forEach(log); // instead of manyArgs(1,2,3,4,5);

function log(a) {
    console.log(a);
}

var reduce = curry(function (func, acc, a) {
    var index = 0, length = a.length;
    while (index < length) acc = func(acc, a[index++]);
    return acc;
});

var sum = reduce(add, 0);

sum([1,2,3,4,5]); // instead of add(1,2,3,4,5);

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

它清晰简洁

另一个示例是，如果要在JavaScript中查找数字列表的总和，请执行以下操作：

[1,2,3,4,5].reduce(add, 0); // instead of add(1,2,3,4,5);

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

有太多有用的抽象可用于构造代码，以至于我根本看不到使用可变参数的好处

但是，我确实使用

参数

对象作为默认值：

function foo(a,b,c) {
    switch (arguments.length) {
    case 0: a = "default argument for a";
    case 1: b = "default argument for b";
    case 2: c = "default argument for c";
    }

    // do something with a, b & c
}

因此，我建议你们不要使用变量参数。为代码找到更好的抽象。在我用JavaScript编程的8年中，我从未遇到过使用可变参数的需要

---

编辑：我主张使用更实用的方法来编写代码。我们可以使用咖喱使代码更加简洁：

function curry(func, length, args) {
    switch (arguments.length) {
    case 1: length = func.length;
    case 2: args = [];
    }

    var slice = args.slice;

    return function () {
        var len = arguments.length;
        var a = args.concat(slice.call(arguments));
        if (len >= length) return func.apply(this, a);
        return curry(func, length - len, a);
    };
}

使用

curry

我们可以将sum示例重写如下：

[1,2,3,4,5].forEach(log); // instead of manyArgs(1,2,3,4,5);

function log(a) {
    console.log(a);
}

var reduce = curry(function (func, acc, a) {
    var index = 0, length = a.length;
    while (index < length) acc = func(acc, a[index++]);
    return acc;
});

var sum = reduce(add, 0);

sum([1,2,3,4,5]); // instead of add(1,2,3,4,5);

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

至于

Array.prototype.push

，因为它改变了输入数组而不是创建一个新的数组，所以我更喜欢使用

Array.concat（[element]）

而不是

Array.push（element）

：

那么，以这种方式编写代码的优势是什么：

咖喱真是太棒了。它允许您从旧函数创建新函数

您将数组传递给函数，而不是使用可变参数。因此，您不需要任何特殊的方式来指示函数使用

参数

假设您必须找到名为

array

的数组的和。使用此方法，只需执行

求和（数组）

。如果使用可变参数，则需要执行

add.apply（null，array）

假设您要查找

a

，

b

和

c

之和。与添加（a，b，c）相比，您需要做的就是

求和（[a，b，c]）

。您需要在额外的

[]

括号中添加内容。但是这样做会使代码更容易理解。根据“显式优于隐式”

---

这就是我在程序中从不使用可变参数的一些原因。

最清楚的方法是使用中可用的扩展运算符（它们被称为“splats”，三个点位于标识符之后）和（它们被称为“rest参数”）

// Using ES6 syntax ...
var foo = function(/*...args*/){
    // shim Array.from, then
    var args = Array.from(arguments);
    // or
    var args = [].slice.call(arguments);
};

//函数接受n个参数并使它们变得漂亮。
函数manyArgs（…args）{
对于（变量i=0；i

---

当然，如果你处在一个可以使用它们的环境中。它既可以更好地进行自我记录，又可以避免乱搞

参数

请务必记住

参数

对象的名称。我个人使用的

var_args

是Google风格指南/闭包编译器中推荐的。如果这真的为第一次查看未注释函数的人提供了有用的提示，谁知道呢。@Pointy谢谢链接。有趣的东西。只是想澄清一下，你的问题是如何表示（包括注释）函数具有可选参数？@torazaburo不一定是可选的，但可以表示函数是可变的。+！用于可选参数的开关/case/fallthrough模式。当您不能使用

a=a | |“default”

时，使用开关的技巧很好。我不得不说我发现

add（1,2,3,4,5）

比

[1,2,3,4,5]更明显/可读

我想你应该马上联系

Math.max

、

Array.push

、

Array.concat

等的设计师，告诉他们他们的设计是错误的。@torazaburo我从来没有说过使用可变参数是错误的。我只是说有更好的抽象，你不需要使用可变参数。实际上，我从未在两个以上的数字上使用过

Math.max

，也从未在多个元素上使用过

Array.prototype.push

。我使用了

Array.prototype.concat.apply（[]，[[]，…]）

，这有点像在Haskell中使用

concat

：[[a]]->[a]。不管我如何使用它（使用

apply

），我仍然只给它传递了两个参数（

[]

和

[[]，…]

）。@AaditMShah感谢您的注释。我知道你说过“我永远不会使用”，而不是“你永远不应该使用”，我基本上同意你的看法，但同样的情况是，API是为你设计的，也可能是为其他消费者设计的。在某些情况下，

sum（1,2,3）

可以被认为是比

sum（[1,2,3]）

更友好的API，尽管后者更容易实现。在这种情况下，我理解OP的问题，他问他应该如何注释

sum

定义以表明它是可变的。如果要使用ES6语法，那么你可以说

var foo=function（…args）

。这也很好地解决了OP关于如何记录函数的可变性质的问题。@torazaburo不幸的是，函数的定义并不表示函数使用可变参数，除非最终用户正在阅读定义（最终用户很可能没有阅读）。函数调用应该表明函数是可变的，而不是函数定义。你不能期望所有的用户都阅读你的函数定义

// Function takes n arguments and makes them pretty.
function manyArgs(...args) {
    for (var i = 0; i < args.length; i++)
        console.log(args[i]);
}