Что такое псевдомассив arguments?

Объект arguments: псевдомассив в JavaScript

arguments — это специальный объект, доступный внутри каждой функции, который содержит все аргументы, передённые в функцию. Это не настоящий массив, а псевдомассив (array-like object), который ведёт себя как массив, но им не является.

Что такое arguments

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

showArgs(1, 'hello', true);
// Arguments(3) [1, 'hello', true, callee: (...), Symbol(Symbol.iterator): ]

Объект arguments:

• Автоматически доступен в каждой функции
• Содержит все переданные аргументы
• Имеет свойство length (количество аргументов)
• Имеет индексные свойства (0, 1, 2...)
• Не имеет методов массива (map, filter, forEach и т.д.)

Почему это псевдомассив?

function test(a, b, c) {
  console.log(arguments instanceof Array); // false
  console.log(Array.isArray(arguments));   // false
  
  // Но есть как length
  console.log(arguments.length); // 3
  
  // И индексный доступ
  console.log(arguments[0]); // 'a'
  console.log(arguments[1]); // 'b'
}

test('a', 'b', 'c');

Основные свойства arguments

1. length

function sum() {
  console.log('Передано аргументов:', arguments.length);
}

sum(1, 2, 3);        // 3
sum(1);              // 1
sum(1, 2, 3, 4, 5);  // 5

2. Индексный доступ

function greet() {
  const firstName = arguments[0];
  const lastName = arguments[1];
  const age = arguments[2];
  
  console.log(`${firstName} ${lastName}, ${age} лет`);
}

greet('Иван', 'Петров', 30);
// Иван Петров, 30 лет

3. callee (ссылка на саму функцию)

function factorial() {
  const n = arguments[0];
  
  if (n <= 1) return 1;
  
  // arguments.callee ссылается на factorial
  return n * arguments.callee(n - 1);
}

console.log(factorial(5)); // 120

Примечание: в strict mode arguments.callee запрещена.

Случаи использования arguments

1. Переменное количество аргументов

// Старый способ (до rest parameters)
function max() {
  if (arguments.length === 0) return -Infinity;
  
  let maximum = arguments[0];
  for (let i = 1; i < arguments.length; i++) {
    if (arguments[i] > maximum) {
      maximum = arguments[i];
    }
  }
  return maximum;
}

console.log(max(1, 5, 3, 9, 2)); // 9

// Современный способ (rest parameters)
function max(...numbers) {
  return Math.max(...numbers);
}

2. Проксирование аргументов

function logger(callback) {
  return function() {
    console.log('Вызов функции с аргументами:', arguments);
    // Передаём все аргументы оригинальной функции
    return callback.apply(this, arguments);
  };
}

function add(a, b) {
  return a + b;
}

const loggedAdd = logger(add);
console.log(loggedAdd(2, 3)); // Логирует и возвращает 5

3. Преобразование в настоящий массив

function showAll() {
  // Способ 1: Array.prototype.slice
  const argsArray1 = Array.prototype.slice.call(arguments);
  
  // Способ 2: Array.from
  const argsArray2 = Array.from(arguments);
  
  // Способ 3: Spread оператор
  const argsArray3 = [...arguments];
  
  return argsArray1; // Теперь это настоящий массив
}

const result = showAll(1, 2, 3);
console.log(result instanceof Array); // true
console.log(result.map(x => x * 2));  // [2, 4, 6]

Отличие arguments от rest parameters

arguments (старый способ)

function old(a, b) {
  console.log(arguments);      // Arguments [1, 2, undefined]
  console.log(arguments.length); // 3
}

old(1, 2);

Rest parameters (современный способ)

function modern(a, b, ...rest) {
  console.log(rest);        // []
  console.log(rest.length); // 0
}

modern(1, 2);

Сравнение arguments и rest parameters

Практические примеры

1. Функция с опциональными параметрами

// Старый способ (arguments)
function createElement(tag) {
  const attrs = {};
  
  // Все аргументы после первого — атрибуты
  for (let i = 1; i < arguments.length; i += 2) {
    attrs[arguments[i]] = arguments[i + 1];
  }
  
  return { tag, attrs };
}

// Современный способ
function createElement(tag, ...attrs) {
  return { tag, attrs };
}

2. Логирование с неопределённым количеством параметров

function log() {
  // Добавляем timestamp
  const timestamp = new Date().toISOString();
  const args = Array.from(arguments);
  
  console.log(`[${timestamp}]`, ...args);
}

log('Error:', 'Something went wrong', 500);
// [2024-01-01T12:00:00.000Z] Error: Something went wrong 500

3. Декоратор функции

function withLogging(fn) {
  return function() {
    console.log(`Вызов ${fn.name} с аргументами:`, arguments);
    const result = fn.apply(this, arguments);
    console.log(`Результат:`, result);
    return result;
  };
}

function multiply(a, b) {
  return a * b;
}

const logged = withLogging(multiply);
logged(3, 4);
// Вызов multiply с аргументами: Arguments(2) [3, 4]
// Результат: 12

Ограничения arguments

1. В стрелочных функциях arguments не работает

const func = () => {
  console.log(arguments); // ReferenceError: arguments is not defined
};

func(1, 2, 3);

Решение:

const func = (...args) => {
  console.log(args); // [1, 2, 3]
};

func(1, 2, 3);

2. arguments — это не обычный массив

function test() {
  arguments.map(x => x * 2); // Ошибка! arguments.map не функция
}

test(1, 2, 3);

3. В strict mode нельзя использовать arguments.callee

'use strict';

function factorial() {
  return arguments.callee(n - 1); // TypeError
};

Когда НЕ использовать arguments

// Плохо: неясная сигнатура
function process() {
  const name = arguments[0];
  const age = arguments[1];
  const email = arguments[2];
}

// Хорошо: ясная сигнатура
function process(name, age, email) {
  // код
}

// Или с rest parameters
function process(...items) {
  // код
}

Современный подход

В современном JavaScript используй:

1. Именованные параметры — когда количество известно

function greet(name, surname, age) {}

1. Rest parameters — когда количество переменное

function sum(...numbers) {
  return numbers.reduce((a, b) => a + b);
}

1. Объекты параметров — для множества опций

function config({ theme, language, notifications }) {}

Ключевые выводы

1. arguments — это псевдомассив, доступный в каждой функции
2. Содержит все переданные аргументы через индексы (0, 1, 2...)
3. Имеет свойство length, но не методы массива
4. Не работает в стрелочных функциях и strict mode
5. Современный способ — rest parameters (...args)
6. Rest parameters — это настоящий массив и намного удобнее
7. Избегай arguments в новом коде, используй rest parameters