arguments - объект со всеми аргументами функции в JavaScript

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

Если говорить просто, arguments позволяет получить все переданные значения, даже если параметры функции заранее не перечислены.

Синтаксис

Специально объявлять arguments не нужно.

Он появляется автоматически внутри обычной функции.

function show() {
  console.log(arguments);
}

show(10, 20, 30);

Что такое arguments

arguments хранит все аргументы вызова.

function show() {
  console.log(arguments[0]);
  console.log(arguments[1]);
  console.log(arguments[2]);
}

show("a", "b", "c");
// "a"
// "b"
// "c"

По нему можно обращаться по индексу почти как по массиву.

У arguments есть length

Через arguments.length можно узнать, сколько аргументов реально передали в функцию.

function show() {
  console.log(arguments.length);
}

show(1, 2, 3); // 3
show(); // 0

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

arguments не зависит от списка параметров

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

function greet(name) {
  console.log(name);
  console.log(arguments);
}

greet("Анна", 25, true);

Здесь:

• name получит только первый аргумент
• arguments сохранит все переданные значения

arguments - не настоящий массив

Это очень важный момент.

arguments похож на массив, потому что у него есть индексы и length, но это не обычный массив.

function show() {
  console.log(Array.isArray(arguments)); // false
}

show(1, 2, 3);

Из-за этого методы массива вроде map(), filter() и reduce() напрямую на arguments не работают.

Как превратить arguments в массив

Если нужен именно массив, arguments можно преобразовать.

Например, так:

function show() {
  const args = Array.from(arguments);
  console.log(args);
}

show(1, 2, 3); // [1, 2, 3]

После этого уже можно использовать методы массива.

function sum() {
  const numbers = Array.from(arguments);
  return numbers.reduce((total, number) => total + number, 0);
}

console.log(sum(1, 2, 3)); // 6

Пример: функция с любым количеством аргументов

Раньше arguments часто использовали именно для таких задач.

function sum() {
  let total = 0;

  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }

  return total;
}

console.log(sum(1, 2, 3)); // 6
console.log(sum(10, 20, 30, 40)); // 100

Такой подход до сих пор работает и хорошо показывает идею arguments.

arguments есть только у обычных функций

У стрелочных функций своего arguments нет.

const show = () => {
  console.log(arguments);
};

Такой код приведёт к ошибке или будет брать arguments из внешней области, если она есть, поэтому рассчитывать на него в стрелочной функции не стоит.

Если нужно собрать аргументы у стрелочной функции, обычно используют rest-параметры.

Чем arguments отличается от rest-параметров

Эти вещи часто сравнивают, потому что обе связаны с аргументами функции.

Главные различия такие:

• arguments - специальный объект внутри обычной функции
• rest-параметр нужно объявлять явно
• arguments не является настоящим массивом
• rest-параметр всегда создаёт настоящий массив
• rest работает и в стрелочных функциях

arguments:

function show() {
  console.log(arguments);
}

Rest:

function show(...args) {
  console.log(args);
}

В современном коде rest-параметры чаще удобнее и понятнее.

Когда arguments всё ещё полезно знать

arguments полезно понимать, потому что:

• он часто встречается в старом коде
• он помогает понять, как раньше работали с произвольным количеством аргументов
• его иногда используют в обычных функциях без rest-параметров
• он встречается в примерах с call() и apply()

Пример:

function logAll() {
  console.log(Array.prototype.join.call(arguments, ", "));
}

logAll("HTML", "CSS", "JavaScript");
// "HTML, CSS, JavaScript"

Когда лучше выбрать rest-параметры

Если вы пишете современный код, чаще удобнее использовать rest-параметры.

function sum(...numbers) {
  return numbers.reduce((total, number) => total + number, 0);
}

Здесь код обычно получается:

• короче
• понятнее
• удобнее для работы с методами массива

Поэтому arguments важно знать, но для новых функций чаще выбирают rest.

Частые ошибки

Думать, что arguments - это массив

function show() {
  console.log(Array.isArray(arguments)); // false
}

У arguments есть индексы и length, но это не обычный массив.

Пытаться сразу вызвать map() или reduce() у arguments

function sum() {
  // arguments.reduce(...) // ошибка
}

Сначала arguments нужно превратить в массив или использовать rest-параметры.

Использовать arguments в стрелочной функции

const show = () => {
  console.log(arguments);
};

У стрелочной функции собственного arguments нет.

Путать параметры функции и реальные аргументы вызова

function greet(name) {
  console.log(name);
  console.log(arguments.length);
}

greet("Анна", "Игорь");

Параметр name один, но аргументов вызова здесь два.

Выбирать arguments, когда нужен обычный массив

Если дальше нужно активно использовать методы массива, rest-параметры обычно удобнее.

Быстрая памятка

• arguments - это специальный объект внутри обычной функции
• он содержит все аргументы вызова
• у arguments есть индексы и length
• arguments не является настоящим массивом
• у стрелочных функций собственного arguments нет
• в современном коде arguments часто заменяют rest-параметрами

Коротко

arguments в JavaScript нужен, чтобы получить все аргументы, переданные в обычную функцию. Главное, что стоит запомнить: он похож на массив, но не является настоящим массивом, а в современном коде его часто заменяют rest-параметрами вроде ...args.