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

Ответ

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

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

Ключевые особенности arguments:

  • Псевдомассив: Имеет свойство length и доступ к элементам по индексу (arguments[0]), но не имеет методов массива (forEach, map, filter).
  • Только для обычных функций: В стрелочных функциях arguments ссылается на arguments внешней функции.
  • Устарел: В современном JS вместо arguments рекомендуется использовать rest-параметры (...args).

Пример функции с arguments и её тестирование:

// Код приложения (legacy)
function sumAll() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

// Автотест для этой функции (например, с использованием Jest)
test('sumAll should correctly sum any number of arguments', () => {
  expect(sumAll(1, 2)).toBe(3);
  expect(sumAll(5, 10, 15, 20)).toBe(50);
  expect(sumAll()).toBe(0); // Важный граничный случай: нет аргументов
});

Современная альтернатива — Rest-параметры:

// Современный код, который проще тестировать
const sumAllModern = (...args) => {
  return args.reduce((accumulator, current) => accumulator + current, 0);
};
// Тест остаётся идентичным, что демонстрирует важность тестирования через публичный интерфейс.

Вывод для QA: При написании или ревью автотестов на JavaScript обращайте внимание на использование arguments в коде продукта, так как это может влиять на поведение функции, особенно в граничных случаях (ноль аргументов, большое количество аргументов).

Ответ 18+ 🔞

Слушай, вот объясняю, как бабушке у подъезда. Есть в JavaScript такая древняя, блядь, штука — arguments. Представь себе, ты заходишь в функцию, как в бар, а там уже на стойке лежит этот arguments — типа список всего, что тебе накидали, когда вызывали. Даже если ты в объявлении функции нихуя не указал, что принимать.

С точки зрения QA-инженера, который пишет автотесты, это знание — как грязный секрет старого кода. Надо понимать, с каким зверем имеешь дело, чтобы не обосраться с тестами.

В чём, блядь, прикол и подвох arguments:

  • Псевдомассив, ёпта: У него есть длина (length) и к элементам можно по индексу лезть (arguments[0]), но если попробуешь вызвать arguments.map() — получишь ошибку, как от мандарина с ушами. Не массив он, хитрая жопа.
  • Только для старых функций: В обычных function — работает. В современных стрелочных (=>) — нихуя, там он смотрит наружу, на внешнюю функцию, если она есть. Если нет — будет ошибка, и ты охуеешь.
  • Устарел, как кассетный плеер: Сейчас все крутые ребята используют rest-параметры (...args). Это и есть правильный, современный путь.

Вот смотри, пример legacy-кода и как его тестить:

// Код приложения (старый, но иногда живой)
function sumAll() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

// Автотест для этой функции (например, с использованием Jest)
test('sumAll should correctly sum any number of arguments', () => {
  expect(sumAll(1, 2)).toBe(3);
  expect(sumAll(5, 10, 15, 20)).toBe(50);
  expect(sumAll()).toBe(0); // Важный граничный случай: нет аргументов
});

Видишь? Функция нихуя не объявляет, что берёт, но мы можем в тестах запихнуть в неё овердохуища чисел. И важно проверить граничный случай — а что, если нихуя не передали? Вернёт ли ноль? А то бывает, старый код на таком ломается.

А вот как сейчас правильно делать:

// Современный код, который проще тестировать
const sumAllModern = (...args) => {
  return args.reduce((accumulator, current) => accumulator + current, 0);
};
// Тест остаётся идентичным, что демонстрирует важность тестирования через публичный интерфейс.

Итог для QA-инженера, чувак: Когда лезешь в старый код и видишь этот arguments — подозрение ебать чувствуй. Сразу смотри, как функция ведёт себя с нулём аргументов, с одной тонкой, с кучей. Потому что эта хуйня — источник неочевидных багов, которые потом вылазят, как чёрт из табакерки. А твоя работа — этих чертей заранее выковыривать.