What Is the arguments Object?

The arguments object is a special object that you get inside every function that is not an arrow function. It holds the values that the caller passed in, in the order they were passed, and it also has a length property. It is not a real array, because it has no array methods such as map and filter.

function sum() {
  console.log('how many arguments:', arguments.length);
  console.log('type of the first one:', typeof arguments[0]);
  console.log('is it a real array:', Array.isArray(arguments));

  let total = 0;
  for (const value of arguments) {
    total += value;
  }
  return total;
}

console.log('result:', sum(1, 2, 3));

// Turn it into a real array when you need array behaviour.
function asArray() {
  return Array.from(arguments);
}

console.log('as an array:', asArray('a', 'b'));

Because it behaves like an array, you can read it by index and you can walk through it with a loop. What you cannot do is call map or filter on it directly. The simple fix is to convert it first, either with Array.from(arguments) or with the spread operator [...arguments].

One of its quirks catches people out. In sloppy mode, the arguments object is linked to the parameter list, so changing a parameter also changes the matching entry in arguments, and the other way round as well. Strict mode removed that link, and because ES modules are always strict, the strict behaviour is the one you get in modern code.

Another quirk is the arrow function case. Arrow functions do not have an arguments object of their own. Inside an arrow function, the word arguments refers to the arguments object of the function that surrounds it, or it fails completely at the top level of a module where there is no surrounding function.

There is one more thing to know. The arguments object is not a replacement for a rest parameter when you only care about the first few arguments. The common pattern is to name the first parameter and then collect the rest, which gives you both, with a real array and no link between the parameters.

The main reason is that a rest parameter gives you a real array with all of the real array methods, and it also removes the quirks that make the arguments object surprising.

Here is what that looks like in practice. The rest parameter gives you the length, the index access, and the iteration behaviour you actually want, plus map, filter, and reduce. That means you no longer have to convert the result with Array.from before you can use it. It also behaves predictably with the rest of the parameter list. You can name the first argument, give the second one a default value, and collect the remainder, and all of those values sit in the same scope with no link between the parameters and the collected array.

Arrow functions are the other reason. Since they do not have an arguments object, any helper that you write with an arrow needs rest parameters to be usable at all. Writing new code with rest parameters means that the same function works whether it is an arrow or not, which removes a whole class of later refactoring.

There is also a performance point worth one sentence. The arguments object creates a mapped-like view over the arguments, and that costs more than simply collecting them into an array. On a hot path with many arguments, the rest parameter is measurably cheaper.

What the arguments object still offers is the ability to read the arguments of a function whose signature you did not write yourself. That shows up when you are wrapping a function and want to forward every argument. Even there, rest parameters do the job well. You declare a rest parameter and you spread it into the call that you forward to.