是否有可能得到一个函数的所有参数作为单一对象内的函数?

在PHP中有func_num_args和func_get_args，在JavaScript中也有类似的东西吗?

218497 次浏览
小开
最佳答案

对于现代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:

使用arguments。你可以像访问数组一样访问它。参数的个数使用arguments.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中，使用Array.from:

function 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"

< b >

对于非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) }

如果作为bookmarklet运行，您可能需要将每个结构化数据参数包装在Error构造函数中，以便JSON.stringify正常工作。

参考文献

小开

arguments对象是函数参数存储的地方。

arguments对象的行为和看起来像一个数组，它基本上是，它只是没有数组的方法，例如:

< a href = " https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach " > Array.forEach(callback[, thisArg]); < / >

< a href = " https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map " > Array.map(callback[, thisArg]) < / >

< a href = " https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter " > Array.filter(callback[, thisArg]); < / >

< a href = " https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice " > Array.slice(begin[, end]) < / >

< a href = " https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf " > Array.indexOf(searchElement[, fromIndex]) < / >

我认为将arguments对象转换为真正的数组的最佳方法如下:

argumentsArray = [].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)

结果:

< p >比;value === name < br > >value === 1 < br > >value === Object {} < br > >value === two < br > >value === 3 < br > < / p >
小开

如果您愿意，还可以将其转换为数组。如果Array泛型可用:

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")
小开

是的，如果你不知道在函数声明时可能有多少参数，那么你可以声明不带形参的函数，并且可以通过函数调用时传递的参数数组访问所有变量。

小开

ES6允许使用“…”符号指定函数参数的构造，例如

function testArgs (...args) {
// Where you can test picking the first element
console.log(args[0]);
}
小开
与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}

< a href = " https://codepen.io/fnocke/pen/mmoxOr?编辑=0010" rel="nofollow noreferrer">https://codepen.io/fnocke/pen/mmoxOr?编辑= 0010 < / >

小开

在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');

~拉胡尔·达克什


提交答案