No PHP existe func_num_args
e func_get_args
, existe algo semelhante ao JavaScript?
No PHP existe func_num_args
e func_get_args
, existe algo semelhante ao JavaScript?
Respostas:
Use arguments
. Você pode acessá-lo como uma matriz. Use arguments.length
para o número de argumentos.
Os argumentos são um objeto semelhante a uma matriz (não uma matriz real). Exemplo de função ...
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>');
}
Experimente...
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]
Os detalhes completos: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments
O ES6 permite uma construção em que um argumento de função é especificado com uma notação "...", como
function testArgs (...args) {
// Where you can test picking the first element
console.log(args[0]);
}
a = () => {console.log(arguments);}; a('foo');
dá -- Uncaught ReferenceError: arguments is not defined
Contudo a = (...args) => {console.log(args);}; a('foo');
dá["foo"]
O arguments
objeto é o local onde os argumentos das funções são armazenados.
O objeto argumentos atua e se parece com uma matriz, basicamente é, simplesmente não possui os métodos que as matrizes possuem, por exemplo:
Array.forEach(callback[, thisArg]);
Array.map(callback[, thisArg])
Array.filter(callback[, thisArg]);
Array.indexOf(searchElement[, fromIndex])
Eu acho que a melhor maneira de converter um arguments
objeto em uma matriz real é assim:
argumentsArray = [].slice.apply(arguments);
Isso tornará uma matriz;
reutilizável:
function ArgumentsToArray(args) {
return [].slice.apply(args);
}
(function() {
args = ArgumentsToArray(arguments);
args.forEach(function(value) {
console.log('value ===', value);
});
})('name', 1, {}, 'two', 3)
resultado:
>
value === name
>value === 1
>value === Object {}
>value === two
>value === 3
[].slice.apply(arguments);
não pode ser o melhor caminho, pois causa uma alocação desnecessária de array vazio.
Você também pode convertê-lo em uma matriz, se preferir. Se os genéricos de matriz estiverem disponíveis:
var args = Array.slice(arguments)
De outra forma:
var args = Array.prototype.slice.call(arguments);
do Mozilla MDN :
Você não deve dividir os argumentos porque isso impede otimizações nos mecanismos JavaScript (V8, por exemplo).
function foo() { foo.bar = JSON.stringify(arguments); foo.baz = JSON.parse(foo.bar); }
se for necessária preservação em vez de stringification, use o algoritmo de clonagem estruturada interno . Se os nós do DOM forem transmitidos, use XMLSerializer como em uma pergunta não relacionada . with (new XMLSerializer()) {serializeToString(document.documentElement) }
Como muitos outros apontaram, arguments
contém todos os argumentos passados para uma função.
Se você quiser chamar outra função com os mesmos argumentos, use apply
Exemplo:
var is_debug = true;
var debug = function() {
if (is_debug) {
console.log.apply(console, arguments);
}
}
debug("message", "another argument")
Resposta semelhante a Gunnar, com um exemplo mais completo: você pode até devolver de maneira transparente a coisa toda:
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 });
Resultado:
foo
bar
true
42
["yes","no"]
{"banana":true}
Sim, se você não tem idéia de quantos argumentos são possíveis no momento da declaração da função, você pode declarar a função sem parâmetros e pode acessar todas as variáveis pela matriz de argumentos que são passadas no momento da chamada da função.
No ES6, você pode fazer algo assim:
function foo(...args)
{
let [a,b,...c] = args;
console.log(a,b,c);
}
foo(1, null,"x",true, undefined);
No ES6, use 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"
Para código não ES6, use JSON.stringify e 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]
Se a preservação for necessária em vez da stringificação, use o algoritmo de clonagem estruturada interna .
Se os nós do DOM forem transmitidos, use XMLSerializer como em uma pergunta não relacionada .
with (new XMLSerializer()) {serializeToString(document.documentElement) }
Se estiver executando como um bookmarklet, pode ser necessário agrupar cada argumento de dados estruturados em um construtor de Erro para JSON.stringify
funcionar corretamente.
Referências
function
, não para as=>
funções de seta gorda do ES2015 + . Para aqueles, você quer usar...args
na definição da função assim:(...args) => console.log(args)
.