对于现代 Javascript 或 Typescript：
class Foo {
reallyCoolMethodISwear(...args) { return args.length; }
}
function reallyCoolFunction(i, ...args) { return args[i]; }
const allHailTheLambda = (...args) => {
return args.constructor == Array;
};
const x = new Foo().reallyCoolMethodISwear(0, 1, 2, 3, 4);
const y = reallyCoolFunction(3, 0, 1, 2, 3, 4, 5, 6);
const z = allHailTheLambda(43110, "world");
console.log(x, y, z); // 5 3 true
对于古老的 Javascript：
argumentsarguments.length参数是类似数组的对象（不是实际的数组）。示例功能...
function testArguments () // <-- notice no arguments specified
{
console.log(arguments); // outputs the arguments to the console
var htmlOutput = "";
for (var i=0; i < arguments.length; i++) {
htmlOutput += '<li>' + arguments[i] + '</li>';
}
document.write('<ul>' + htmlOutput + '</ul>');
}
尝试一下...
testArguments("This", "is", "a", "test"); // outputs ["This","is","a","test"]
testArguments(1,2,3,4,5,6,7,8,9); // outputs [1,2,3,4,5,6,7,8,9]
完整详细信息：https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments
ES6 允许使用“...”符号指定函数参数的构造，例如
function testArgs (...args) {
// Where you can test picking the first element
console.log(args[0]);
}
argumentsarguments 对象的行为和外观都像一个数组，它基本上就是这样，只是没有数组所具有的方法，例如：
Array.forEach(callback[, thisArg]);Array.map(callback[, thisArg])Array.filter(callback[, thisArg]);Array.slice(begin[, end])Array.indexOf(searchElement[, fromIndex])我认为将
argumentsargumentsArray = [].slice.apply(arguments);
这将使其成为一个数组；
可重复使用：
function ArgumentsToArray(args) {
return [].slice.apply(args);
}
(function() {
args = ArgumentsToArray(arguments);
args.forEach(function(value) {
console.log('value ===', value);
});
})('name', 1, {}, 'two', 3)
结果：
>
value === name
>value === 1
>value === Object {}
>value === two
>value === 3
如果您愿意，也可以将其转换为数组。如果数组泛型可用：
var args = Array.slice(arguments)
否则：
var args = Array.prototype.slice.call(arguments);
来自 Mozilla MDN：
您不应该对参数进行切片，因为它会阻止优化 JavaScript 引擎（例如 V8）。
正如许多其他人指出的那样，
arguments如果您想使用相同的参数调用另一个函数，请使用
apply示例：
var is_debug = true;
var debug = function() {
if (is_debug) {
console.log.apply(console, arguments);
}
}
debug("message", "another argument")
与 Gunnar 类似的答案，有更完整的示例： 您甚至可以透明地返回整个内容：
function dumpArguments(...args) {
for (var i = 0; i < args.length; i++)
console.log(args[i]);
return args;
}
dumpArguments("foo", "bar", true, 42, ["yes", "no"], { 'banana': true });
输出：
foo
bar
true
42
["yes","no"]
{"banana":true}
是的，如果您不知道在函数声明时可以有多少个参数，那么您可以声明不带参数的函数，并且可以通过在函数调用时传递的参数数组访问所有变量。
在 ES6 中你可以这样做：
function foo(...args)
{
let [a,b,...c] = args;
console.log(a,b,c);
}
foo(1, null,"x",true, undefined);希望这有帮助：
function x(...args) {
console.log( {...[...args] } );
}
x({a:1,b:2}, 'test');
输出：
{ '0': { a: 1, b: 2 }, '1': 'test' }
希望这可能是有用的代码：
function lazyLoadIcons(){
for(let i = 0; i < arguments.length; i++) {
var elements = document.querySelectorAll(arguments[i]);
elements.forEach(function(item){
item.classList.add('loaded');
});
}
}
lazyLoadIcons('.simple-2col', '.ftr-blue-ad', '.btm-numb');
~拉胡尔·达克什
在 ES6 中，使用
Array.fromfunction foo()
{
foo.bar = Array.from(arguments);
foo.baz = foo.bar.join();
}
foo(1,2,3,4,5,6,7);
foo.bar // Array [1, 2, 3, 4, 5, 6, 7]
foo.baz // "1,2,3,4,5,6,7"
对于非 ES6 代码，请使用 JSON.stringify 和 JSON.parse：
function foo()
{
foo.bar = JSON.stringify(arguments);
foo.baz = JSON.parse(foo.bar);
}
/* Atomic Data */
foo(1,2,3,4,5,6,7);
foo.bar // "{"0":1,"1":2,"2":3,"3":4,"4":5,"5":6,"6":7}"
foo.baz // [object Object]
/* Structured Data */
foo({1:2},[3,4],/5,6/,Date())
foo.bar //"{"0":{"1":2},"1":[3,4],"2":{},"3":"Tue Dec 17 2013 16:25:44 GMT-0800 (Pacific Standard Time)"}"
foo.baz // [object Object]
如果需要保存而不是字符串化，请使用内部结构化克隆算法。
如果传递了 DOM 节点，请使用 XMLSerializer，就像在不相关的问题中一样。
with (new XMLSerializer()) {serializeToString(document.documentElement) }
如果作为书签运行，您可能需要将每个结构化数据参数包装在错误构造函数中，以便
JSON.stringify参考文献