Объект arguments

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

Попробуйте

function func1(a, b, c) {
  console.log(arguments[0]);
  // Expected output: 1

  console.log(arguments[1]);
  // Expected output: 2

  console.log(arguments[2]);
  // Expected output: 3
}

func1(1, 2, 3);

Описание

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

Например, если функции передано 3 аргумента, вы можете получить к ним доступ следующим образом:

arguments[0]; // first argument
arguments[1]; // second argument
arguments[2]; // third argument

Объект arguments полезен для функций, вызываемых с большим количеством аргументов, чем они формально объявлены принимать, что называется вариативными функциями, такими как Math.min(). Следующий пример функции принимает любое количество строковых аргументов и возвращает самый длинный из них:

function longestString() {
  let longest = "";
  if (arguments.length === 0) {
    throw new TypeError("At least one string is required");
  }
  for (const arg of arguments) {
    if (arg.length > longest.length) {
      longest = arg;
    }
  }
  return longest;
}

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

Назначение индексам

Каждому индексу аргумента также можно присвоить или переназначить значение:

arguments[1] = "new value";

Нестрогие функции, имеющие только простые параметры (то есть без остаточных, значений по умолчанию или деструктурированных параметров), будут синхронизировать новое значение параметров с объектом arguments и наоборот:

function func(a) {
  arguments[0] = 99; // updating arguments[0] also updates a
  console.log(a);
}
func(10); // 99

function func2(a) {
  a = 99; // updating a also updates arguments[0]
  console.log(arguments[0]);
}
func2(10); // 99

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

function funcWithDefault(a = 55) {
  arguments[0] = 99; // updating arguments[0] does not also update a
  console.log(a);
}
funcWithDefault(10); // 10

function funcWithDefault2(a = 55) {
  a = 99; // updating a does not also update arguments[0]
  console.log(arguments[0]);
}
funcWithDefault2(10); // 10

// An untracked default parameter
function funcWithDefault3(a = 55) {
  console.log(arguments[0]);
  console.log(arguments.length);
}
funcWithDefault3(); // undefined; 0

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

arguments — это объект, похожий на массив

arguments — это объект, похожий на массив, что означает, что arguments имеет свойство length и свойства с индексацией от нуля, но у него нет встроенных методов Array, таких как forEach() или map(). Однако его можно преобразовать в настоящий Array, используя один из методов slice(), Array.from() или синтаксис распространения.

const args = Array.prototype.slice.call(arguments);
// or
const args = Array.from(arguments);
// or
const args = [...arguments];

Для распространенных случаев использования достаточно использовать его как объект, похожий на массив, поскольку он является итерируемым и имеет length и числовые индексы. Например, Function.prototype.apply() принимает объекты, похожие на массивы.

function midpoint() {
  return (
    (Math.min.apply(null, arguments) + Math.max.apply(null, arguments)) / 2
  );
}

console.log(midpoint(3, 1, 4, 1, 5)); // 3

Свойства

arguments.callee Устарело

Ссылка на текущую выполняющуюся функцию, к которой принадлежат аргументы. Запрещено в строгом режиме.

arguments.length

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

arguments[Symbol.iterator]()

Возвращает новый объект итератора массива, содержащий значения для каждого индекса в arguments.

Примеры

Определение функции, объединяющей несколько строк

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

function myConcat(separator) {
  const args = Array.prototype.slice.call(arguments, 1);
  return args.join(separator);
}

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

myConcat(", ", "red", "orange", "blue");
// "red, orange, blue"

myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
// "elephant; giraffe; lion; cheetah"

myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
// "sage. basil. oregano. pepper. parsley"

Определение функции, создающей HTML-списки

Этот пример определяет функцию, которая создает строку, содержащую HTML для списка. Единственным формальным аргументом функции является строка, которая является "u", если список должен быть неупорядоченным (маркированным), или "o", если список должен быть упорядоченным (нумерованным). Функция определяется следующим образом:

function list(type) {
  let html = `<${type}l><li>`;
  const args = Array.prototype.slice.call(arguments, 1);
  html += args.join("</li><li>");
  html += `</li></${type}l>`; // end list
  return html;
}

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

list("u", "One", "Two", "Three");
// "<ul><li>One</li><li>Two</li><li>Three</li></ul>"

Использование typeof с arguments

Оператор typeof возвращает 'object' при использовании с arguments

console.log(typeof arguments); // 'object'

Тип отдельных аргументов можно определить, проиндексировав arguments:

console.log(typeof arguments[0]); // returns the type of the first argument

Спецификации

Совместимость с браузерами

См. также

• Руководство по функциям
• Функции
• Остаточные параметры