Можно ли получить все аргументы функции как отдельный объект внутри этой функции?

Ответы:

346

Использование arguments. Вы можете получить к нему доступ как массив. Используйте arguments.lengthдля количества аргументов.

Томас Эдинг
источник
46
Это работает только для традиционного JavaScript function, но не для функций ES2015 + жирная стрелка =>. Для тех, вы хотите использовать ...argsв определении функции следующим образом: (...args) => console.log(args).
Sawtaytoes
141

В аргументов является массивом, как объект (не фактический массив). Пример функции ...

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

Люк
источник
3
Почему бы не опубликовать результат здесь тоже? :)
Джонатан Азулай
2
Это намного лучше, чем принятый ответ, потому что он содержит рабочий фрагмент кода и показывает вывод. Принятый ответ слишком скуден.
Mac
Хороший ответ ... будет отличным ответом с расширением "не фактического массива"
terpinmd
Я добавил ссылку на простое описание: «объект в виде массива» - это просто «объект, имеющий свойство длины неотрицательного целого числа и обычно некоторые индексированные свойства». Из ссылки Mozilla: «Он похож на массив, но не имеет никаких свойств массива, кроме длины».
Люк
31

ES6 допускает конструкцию, в которой аргумент функции указывается с помощью обозначения «...», такого как

function testArgs (...args) {
 // Where you can test picking the first element
 console.log(args[0]); 
}
Гуннар Форсгрен - Mobimation
источник
3
Это кажется единственным способом при использовании функции стрелки. a = () => {console.log(arguments);}; a('foo');дает -- Uncaught ReferenceError: arguments is not defined Однако a = (...args) => {console.log(args);}; a('foo');дает["foo"]
Дэвид Баукум
1
@DavidBaucum это правильно. Потому что функция стрелки не создает новую область видимости, а «аргументы» собираются из области видимости. Но в худшем случае это не ReferenceError. Дело в том, что «аргументы» собираются из внешней области видимости. Тогда вы не получите исключения и, возможно, странные ошибки в вашем приложении.
pgsandstrom
1
Это также называется «параметрами покоя», см. Developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
Деннис
21

argumentsОбъект , где функция аргументы сохраняются.

Объект arguments действует и выглядит как массив, в основном это так, у него просто нет методов, которые делают массивы, например:

Array.forEach(callback[, thisArg]);

Array.map(callback[, thisArg])

Array.filter(callback[, thisArg]);

Array.slice(begin[, end])

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)

результат:

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

iConnor
источник
1
[].slice.apply(arguments);не может быть лучшим способом, потому что это вызывает ненужное выделение пустого массива.
Томас
10

Вы также можете преобразовать его в массив, если хотите. Если доступны дженерики Array:

var args = Array.slice(arguments)

В противном случае:

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

от Mozilla MDN :

Вы не должны разделять аргументы, потому что это предотвращает оптимизацию в механизмах JavaScript (например, V8).

Иман Мохамади
источник
2
Спасибо за обновление. Используйте JSON.stringify и JSON.parse в качестве альтернативы: function foo() { foo.bar = JSON.stringify(arguments); foo.baz = JSON.parse(foo.bar); } если требуется сохранение вместо строкового преобразования , используйте алгоритм внутреннего структурированного клонирования . Если узлы DOM пройдены, используйте XMLSerializer, как в не связанном вопросе . with (new XMLSerializer()) {serializeToString(document.documentElement) }
Пол Свитт
7

Как и многие другие, argumentsсодержит все аргументы, переданные функции.

Если вы хотите вызвать другую функцию с такими же аргументами, используйте apply

Пример:

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

debug("message", "another argument")
Лассе Скиндстад Эберт
источник
4

Аналогичный ответ на Гуннар, с более полным примером: вы можете даже прозрачно вернуть все это:

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}

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

Фрэнк Нок
источник
3

Да, если вы не знаете, сколько аргументов возможно во время объявления функции, вы можете объявить функцию без параметров и получить доступ ко всем переменным по массиву аргументов, который передается во время вызова функции.

Руби Сайни
источник
2

В ES6 вы можете сделать что-то вроде этого:

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

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


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

Камил Келчевски
источник
1
Вы можете даже выполнить `` `функцию foo (a, b, ... c) {console.log (a, b, c); } `` `
TitouanT
-11

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

Для кода не-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правильной работы.

Ссылки

Пол Свитт
источник
3
Во-первых: это клонирует все объекты, которые передаются. Во-вторых: не все можно преобразовать в формат JSON. А именно: функции, объекты DOM, указанные даты преобразуются в строки ...
Джон Дворжак
@JanDvorak Можете ли вы отредактировать мой ответ с помощью функции, которая обрабатывает DOM-объекты, функции и даты?
Пол Свитт
1
+1, пытаясь передать аргументы для сообщения об ошибке в виде строки, объект заканчивается строкой '[Аргументы объекта]', и запись в консоль не отображает значения. Хотя он, кажется, не отвечает на ФП, он отвечает на мой вопрос, спасибо!
Джон