The arguments Object vs. Rest Parameters in JavaScript

For a long time, JavaScript developers handled variable numbers of function arguments through the arguments object. It worked, but it also carried a few rough edges that became more obvious as the language evolved.

Rest parameters gave us a cleaner modern alternative.

If you are learning JavaScript now, it is worth understanding both, because you will still see arguments in older code and in explanations of how functions behave. But if you are writing new code, rest parameters are usually the clearer choice.

What the arguments object is

Inside a normal function, JavaScript provides an arguments object containing the values passed to that function.

function logArguments(): void {  console.log(arguments);}logArguments('a', 'b', 'c');

This lets a function inspect however many arguments it received, even if you did not declare matching named parameters up front.

That made arguments very useful in older JavaScript, especially before some of the modern syntax improvements arrived.

It Looks Array‑Like, but It is Not Really an Array

This is one of the first practical limitations.

arguments has:

• numeric indices
• a length property

but it is not a real array. That means you do not automatically get array methods such as map, filter, or reduce directly on it.

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

That fails because arguments.reduce does not exist.

You can work around that by converting it to an array:

function sum(): number {  const values = Array.from(arguments) as number[];  return values.reduce((total, value) => {    return total + value;  }, 0);}

But that extra ceremony is part of why rest parameters feel cleaner in modern code.

Rest Parameters Give You a Real Array

Rest parameters collect the remaining arguments into a proper array.

const sum = (...values: number[]): number => {  return values.reduce((total, value) => {    return total + value;  }, 0);};

That is immediately easier to read:

• the parameter is named
• the intent is obvious
• the result is a real array
• array methods work naturally

This is one of those language features where the practical improvement is more important than the novelty of the syntax itself.

Rest Parameters Also Make Function Signatures Clearer

With arguments, the function signature can hide what the function expects.

function tagItems() {  // uses arguments internally}

You have to read the body to understand what shape of input is being handled.

With rest parameters, the function announces that it accepts a variable number of items:

const tagItems = (...items: string[]): string[] => {  return items.map((item) => `#${item}`);};

That is a readability win, especially in larger codebases.

arguments is tied to normal functions, not arrow functions

Another important difference is that arrow functions do not have their own arguments object.

const logArguments = (): void => {  console.log(arguments);};

That does not work the way many beginners expect. Arrow functions do not create their own local arguments binding.

Rest parameters avoid this problem entirely because they are part of the function's declared parameters.

const logArguments = (...values: string[]): void => {  console.log(values);};

That works cleanly with arrow functions, which is one more reason rest parameters fit modern JavaScript better.

Named Parameters and Rest Parameters Work Well Together

Another nice advantage is that rest parameters play cleanly with explicit leading parameters.

const formatList = (prefix: string, ...items: string[]): string[] => {  return items.map((item) => `${prefix}${item}`);};

This makes it very obvious which part of the input is fixed and which part is open‑ended.

Doing the same thing with arguments is possible, but usually less elegant because you end up slicing or manually indexing into a more ambiguous structure.

There is still value in understanding arguments

Even if you prefer rest parameters, arguments still matters for two reasons.

First, you will encounter it in older code and older tutorials.

Second, it helps explain some of JavaScript's history and function behaviour. Knowing it exists makes it easier to understand why some legacy functions are written the way they are.

So the goal is not to pretend arguments never mattered. It mattered a great deal. It is just no longer the clearest default in most new code.

Rest Parameters are Not the Same as Spread Syntax

These two often get mentioned together because they share the ... syntax, but they are not identical.

Rest parameters gather multiple incoming values into one array:

const collect = (...items: string[]): string[] => items;

Spread syntax expands an iterable out into individual values:

const items = ['a', 'b', 'c'];collect(...items);

The syntax looks the same because the idea is related, but the direction is opposite.

A Small Comparison Makes the Difference Obvious

Here is an older style with arguments:

function makeSentence(): string {  const words = Array.from(arguments) as string[];  return words.join(' ');}

And here is the rest parameter version:

const makeSentence = (...words: string[]): string => {  return words.join(' ');};

The modern version is shorter, clearer, and easier to type properly.

That comparison explains why rest parameters have largely won in contemporary JavaScript style.

When might arguments still appear?

You are most likely to see arguments in:

• older codebases
• older tutorials
• libraries written before ES2015 syntax became common
• examples discussing JavaScript function internals

If you are maintaining that kind of code, understanding arguments is useful. If you are choosing how to write a new helper or component today, rest parameters are usually the more readable option.

Wrapping up

The arguments object was a long‑standing way to access variable function inputs in JavaScript, but it comes with awkward edges: it is array‑like rather than a true array, it does not fit neatly with arrow functions, and it often hides intent. Rest parameters solve those problems more cleanly, which is why they are usually the better choice in modern code.

Key Takeaways

• arguments exists inside normal functions and contains the values passed in.
• It is array‑like, but not a real array.
• Rest parameters collect remaining arguments into a proper array.
• Arrow functions do not have their own arguments object.
• In modern JavaScript, rest parameters are usually clearer and easier to work with.

Understanding both is useful, but if you are writing fresh code, rest parameters tend to express intent much more cleanly.