是否可以向JavaScript函数发送数量可变的参数？

是否可以从数组向JavaScript函数发送数量可变的参数

var arr = ['a','b','c']

var func = function()
{
    // debug 
    alert(arguments.length);
    //
    for(arg in arguments)
        alert(arg);
}

func('a','b','c','d'); // prints 4 which is what I want, then 'a','b','c','d'
func(arr); // prints 1, then 'Array'

我最近写了很多Python，能够接受并发送varargs是一种很好的模式。e、 g

def func(*args):
   print len(args)
   for i in args:
       print i

func('a','b','c','d'); // prints 4 which is what I want, then 'a','b','c','d'
func(*arr) // prints 4 which is what I want, then 'a','b','c','d'

---

在JavaScript中是否可以发送一个数组作为参数数组处理

更新：从ES6开始，调用函数时只需使用：

func(...arr);

由于ES6还允许将参数作为数组处理，因此也可以在参数列表中使用扩展语法，例如：

function func(...args) {
  args.forEach(arg => console.log(arg))
}

const values = ['a', 'b', 'c']
func(...values)
func(1, 2, 3)

您可以将其与普通参数组合，例如，如果希望分别接收前两个参数，并将其余参数作为数组接收：

function func(first, second, ...theRest) {
  //...
}

也许对您很有用，您可以知道函数需要多少参数：

var test = function (one, two, three) {}; 
test.length == 3;

但无论如何，你可以传递任意数量的参数

与

apply

相比，spread语法更短，更“甜美”，如果不需要在函数调用中设置

this

值，这就是方法

下面是一个例子，这是前一种方法：

var arr = ['a','b','c'];

function func() {
  console.log(this); // 'test'
  console.log(arguments.length); // 3

  for(var i = 0; i < arguments.length; i++) {
    console.log(arguments[i]);
  }

};

func.apply('test', arr);

在ES6中：

const argsArray = [...arguments] // or Array.from(arguments)

---

但是由于扩展语法，现在很少直接使用

参数
对象。
实际上，您可以向任何javascript函数传递任意数量的值。显式命名的参数将获得前几个值，但所有参数都将存储在arguments数组中

要以“解包”形式传递参数数组，可以使用apply，如（c.f.）：

apply
函数有两个参数；对象
此
将绑定到一个数组，并用数组表示参数

some_func = function (a, b) { return b }
some_func.apply(obj, ["arguments", "are", "here"])
// "are"

function logArgs(...args) {
    console.log(args.length)
    for(let arg of args) {
        console.log(arg)
    }
}

它被称为
splat
操作符。您可以在JavaScript中使用
apply
：

var arr = ['a','b','c','d'];
var func = function() {
    // debug 
    console.log(arguments.length);
    console.log(arguments);
}
func('a','b','c','d'); // prints 4 which is what I want, then 'a','b','c','d'
func(arr); // prints 1, then 'Array'
func.apply(null, arr); 

对于从此处重新定向的人员（应而不是标记为此问题的副本）：

如果您试图将数量可变的参数从一个函数传递到另一个函数，由于JavaScript 1.8.5，您只需在第二个函数上调用
apply（）
，并传入
参数：

var caller = function()
{
    callee.apply( null, arguments );
}

var callee = function()
{
    alert( arguments.length );
}

caller( "Hello", "World!", 88 ); // Shows "3".

注意：第一个参数是要使用的
此
参数。传递
null
将从全局上下文调用函数，即作为全局函数而不是某个对象的方法

根据，ECMAScript 5规范重新定义了
apply（）
方法，以接受任何“类似于泛型数组的对象”，而不是严格意义上的数组。因此，您可以直接将
参数
列表传递到第二个函数中

在Chrome 28.0、Safari 6.0.5和IE 10中测试。请试用。
和操作符是计划中的下一个Javascript版本ES6的一部分。到目前为止，只有Firefox支持它们。此代码在FF16+中工作：

var arr = ['quick', 'brown', 'lazy'];

var sprintf = function(str, ...args)
{
    for (arg of args) {
        str = str.replace(/%s/, arg);
    }
    return str;
}

sprintf.apply(null, ['The %s %s fox jumps over the %s dog.', ...arr]);
sprintf('The %s %s fox jumps over the %s dog.', 'slow', 'red', 'sleeping');

请注意spread的awkard语法。
sprintf的常用语法（%s%s狐狸跳过了%s狗，…arr）是。你可以找到

另请注意另一ES6附加组件的使用。这是一个示例程序，用于计算变量参数的整数和整数上的数组。希望这有帮助

var CalculateSum = function(){
    calculateSumService.apply( null, arguments );
}

var calculateSumService = function(){
    var sum = 0;

    if( arguments.length === 1){
        var args = arguments[0];

        for(var i = 0;i<args.length; i++){
           sum += args[i]; 
        }
    }else{
        for(var i = 0;i<arguments.length; i++){
           sum += arguments[i]; 
        }        
    }

     alert(sum);

}


//Sample method call

// CalculateSum(10,20,30);         

// CalculateSum([10,20,30,40,50]);

// CalculateSum(10,20);

var CalculateSum=function（）{
calculateSumService.apply（null，参数）；
}
var calculateSumService=函数（）{
var总和=0；
if（arguments.length==1）{
var args=参数[0]；
对于（var i=0；i而言，截至2015年欧洲标准日，有两种方法

此对象内置于函数中，并适当地引用函数的参数。但从技术上讲，它不是数组，因此典型的数组操作对其不起作用。建议使用
array.from
或spread运算符从中创建数组

我看到其他答案提到使用
slice
。不要这样做。这会阻止优化（来源：）

但是，我认为
arguments
是有问题的，因为它隐藏了函数接受作为输入的内容

function mean(){
    let args = [...arguments];
    return args.reduce((a,b)=>a+b) / args.length;
}

有时，函数头的编写方式如下，以类似C的方式记录参数：

function mean(/* ... */){ ... }

但这是罕见的

至于它有问题的原因，以C为例。C与一种古老的前ANSI语言K&R C向后兼容。K&R C允许函数原型有一个空参数列表

int myFunction();
/* This function accepts unspecified parameters */

ANSI C为
varargs
（
..
）和
void
提供了一种工具，用于指定空参数列表

int myFunction(void);
/* This function accepts no parameters */

许多人不经意地使用
未指定的
参数列表（
int myfunction（）；
）声明函数，因为他们希望函数接受零参数。从技术上讲，这是一个错误，因为函数将接受任何数量的参数

C中正确的
varargs
函数的形式如下：

int myFunction(int nargs, ...);

JavaScript实际上也有类似的功能

/ 
实际上，我已经给你看了排列操作符

...name

它用途非常广泛，还可以在函数的参数列表（“rest参数”）中使用，以一种文档化的方式指定varargs：

function mean(...args){
    return args.reduce((a,b)=>a+b) / args.length;
}

或者作为lambda表达式：

((...args)=>args.reduce((a,b)=>a+b) / args.length)(1,2,3,4,5); // 3

我更喜欢spread运算符。它是干净的和自记录的。
是的，您可以将变量数量的参数传递给函数。您可以使用
apply
来实现这一点

例如：

使用ES6，您可以使用
varagrs
。这将获取参数列表并将其转换为数组

some_func = function (a, b) { return b }
some_func.apply(obj, ["arguments", "are", "here"])
// "are"

function logArgs(...args) {
    console.log(args.length)
    for(let arg of args) {
        console.log(arg)
    }
}

是否希望函数对数组参数或变量参数作出反应？如果是后者，请尝试：

var func = function(...rest) {
  alert(rest.length);

  // In JS, don't use for..in with arrays
  // use for..of that consumes array's pre-defined iterator
  // or a more functional approach
  rest.forEach((v) => console.log(v));
};

但是如果您希望处理数组参数

var fn = function(arr) {
  alert(arr.length);

  for(var i of arr) {
    console.log(i);
  }
};

谢谢，apply做这个把戏，在这种情况下调用不起作用。这是写错的吗？如果函数实际上是一个类的成员，你怎么做？是这样吗
function logArgs(...args) {
    console.log(args.length)
    for(let arg of args) {
        console.log(arg)
    }
}

var func = function(...rest) {
  alert(rest.length);

  // In JS, don't use for..in with arrays
  // use for..of that consumes array's pre-defined iterator
  // or a more functional approach
  rest.forEach((v) => console.log(v));
};

var fn = function(arr) {
  alert(arr.length);

  for(var i of arr) {
    console.log(i);
  }
};