É possível obter todos os argumentos de uma função como objeto único dentro dessa função?

Respostas:

346

Use arguments. Você pode acessá-lo como uma matriz. Use arguments.lengthpara o número de argumentos.

Thomas Eding
fonte
46
Isso funciona apenas para o JavaScript tradicional function, não para as =>funções de seta gorda do ES2015 + . Para aqueles, você quer usar ...argsna definição da função assim: (...args) => console.log(args).
Sawtaytoes
141

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

Lucas
fonte
3
Por que não postar o resultado aqui também? :)
Jonathan Azulay
2
Isso é muito melhor que a resposta aceita, pois contém um trecho de código funcional e mostra a saída. A resposta aceita é muito escassa.
Mac
Boa resposta ... seria uma grande resposta com expansão em "não um array real"
terpinmd
Adicionei um link a uma descrição simples: um "Objeto semelhante a uma matriz" é apenas um "Objeto que possui uma propriedade length de um inteiro não negativo e, geralmente, algumas propriedades indexadas". No link mozilla: "É semelhante a uma matriz, mas não possui propriedades da matriz, exceto o comprimento".
Lucas
31

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]); 
}
Gunnar Forsgren - Mobimation
fonte
3
Esta parece ser a única maneira de usar a função de seta. a = () => {console.log(arguments);}; a('foo');-- Uncaught ReferenceError: arguments is not defined Contudo a = (...args) => {console.log(args);}; a('foo');["foo"]
David Baucum
1
@DavidBaucum está correto. Como a função de seta não cria um novo escopo, e "argumentos" são coletados do escopo. Mas o pior cenário não é um ReferenceError. É que "argumentos" são coletados de um escopo externo. Então você não recebe nenhuma exceção e talvez erros estranhos em seu aplicativo.
Pgsandstrom 18/05
1
Isso também é chamado de "parâmetros de descanso", consulte developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
216 Dennis
21

O argumentsobjeto é 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.slice(begin[, end])

Array.indexOf(searchElement[, fromIndex])

Eu acho que a melhor maneira de converter um argumentsobjeto 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

iConnor
fonte
1
[].slice.apply(arguments);não pode ser o melhor caminho, pois causa uma alocação desnecessária de array vazio.
Thomas Eding
10

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).

Iman Mohamadi
fonte
2
Obrigado pela atualização. Use JSON.stringify e JSON.parse como uma alternativa: 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) }
Paul Sweatte
7

Como muitos outros apontaram, argumentsconté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")
Lasse Skindstad Ebert
fonte
4

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}

https://codepen.io/fnocke/pen/mmoxOr?editors=0010

Frank Nocke
fonte
3

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.

Rubi saini
fonte
2

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

Kamil Kiełczewski
fonte
1
Você pode até fazer `` function foo (a, b, ... c) {console.log (a, b, c); } `` `
TitouanT 23/04/19
-11

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.stringifyfuncionar corretamente.

Referências

Paul Sweatte
fonte
3
Primeiro: isso irá clonar quaisquer objetos que sejam passados. Segundo: nem tudo pode ser codificado para JSON. A saber: funções, objetos DOM, disse datas stringify como cordas ...
John Dvorak
@JanDvorak Você pode editar minha resposta com uma função que lida com objetos, funções e datas do DOM?
Paul Sweatte
1
+1, tentando passar os argumentos para o relatório de erros como uma sequência, o objeto acaba como uma sequência '[object Arguments]' e o registro no console não exibe os valores. Embora não pareça responder ao OP, ele responde à minha pergunta, obrigado!
John