Czy można uzyskać wszystkie argumenty funkcji jako pojedynczy obiekt wewnątrz tej funkcji?

W PHP jest func_num_argsi func_get_argsczy jest coś podobnego do JavaScript?

Zastosowanie arguments. Możesz uzyskać do niej dostęp jak tablicę. Użyj arguments.lengthdla liczby argumentów.

Te argumenty są przedmiotem tablicowej (nie rzeczywisty tablica). Przykładowa funkcja ...

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

Wypróbuj to...

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]

Pełne szczegóły: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments

ES6 pozwala na konstrukcję, w której argument funkcji jest określony za pomocą notacji „...”, takiej jak

function testArgs (...args) {
 // Where you can test picking the first element
 console.log(args[0]); 
}

argumentsObiekt jest gdzie przechowywane są argumenty funkcji.

Obiekt argumentów działa i wygląda jak tablica, po prostu nie ma metod, które wykonują tablice, na przykład:

Array.forEach(callback[, thisArg]);

Array.map(callback[, thisArg])

Array.filter(callback[, thisArg]);

Array.slice(begin[, end])

Array.indexOf(searchElement[, fromIndex])

Myślę, że najlepszym sposobem na konwersję argumentsobiektu do prawdziwej macierzy jest:

argumentsArray = [].slice.apply(arguments);

To sprawi, że będzie tablicą;

wielokrotnego użytku:

function ArgumentsToArray(args) {
    return [].slice.apply(args);
}

(function() {
   args = ArgumentsToArray(arguments);

   args.forEach(function(value) {
      console.log('value ===', value);
   });

})('name', 1, {}, 'two', 3)

wynik:

> value === name
> value === 1
> value === Object {}
> value === two
>value === 3

Możesz także przekonwertować go na tablicę, jeśli wolisz. Jeśli dostępne są ogólne tablice:

var args = Array.slice(arguments)

Inaczej:

var args = Array.prototype.slice.call(arguments);

z Mozilla MDN :

Nie należy kroić argumentów, ponieważ uniemożliwia to optymalizację w silnikach JavaScript (na przykład V8).

Jak wielu zauważyło, arguments zawiera wszystkie argumenty przekazane do funkcji.

Jeśli chcesz wywołać inną funkcję z tymi samymi argumentami, użyj apply

Przykład:

var is_debug = true;
var debug = function() {
  if (is_debug) {
    console.log.apply(console, arguments);
  }
}

debug("message", "another argument")

Podobna odpowiedź do Gunnara, z bardziej kompletnym przykładem: Możesz nawet w przejrzysty sposób zwrócić całość:

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

Wynik:

foo
bar
true
42
["yes","no"]
{"banana":true}

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

Tak, jeśli nie masz pojęcia, ile argumentów jest możliwych w momencie deklaracji funkcji, możesz zadeklarować funkcję bez parametrów i uzyskać dostęp do wszystkich zmiennych za pomocą tablicy argumentów przekazywanych w momencie wywołania funkcji.

W ES6 możesz zrobić coś takiego:

function foo(...args) 
{
   let [a,b,...c] = args;

   console.log(a,b,c);
}


foo(1, null,"x",true, undefined);

W ES6 użyj 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"

W przypadku kodu innego niż ES6 użyj JSON.stringify i 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]

Jeśli zamiast strityfikacji konieczne jest zachowanie, użyj wewnętrznego algorytmu klonowania strukturalnego .

Jeśli węzły DOM zostaną przekazane, użyj XMLSerializer jak w niepowiązanym pytaniu .

with (new XMLSerializer()) {serializeToString(document.documentElement) }

Jeśli działa jako bookmarklet, może być konieczne zawinięcie każdego argumentu danych strukturalnych w konstruktora błędów dla JSON.stringify aby działał poprawnie.

Bibliografia

• Struktura Klon Moduł CommonJS

• JS Object Clone

• MDN: Array.from ()