iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
In a regular JavaScript function, arguments is an array-like object holding the values passed to that particular call. Arrow functions do not create their own arguments object. When code inside an arrow refers to arguments, JavaScript looks for that name in the surrounding lexical scope. If an enclosing regular function supplies one, the arrow reads it. If nothing does, the reference fails. For new code that needs every argument, a rest parameter such as (...args) is the usual replacement, and it works in arrow functions too.
What the arguments object is in a regular function
Every call to a non-arrow function gets an arguments binding that contains the actual values supplied in that call, whether or not the function declares parameters for them. Indexed access starts at zero, and arguments.length reports how many values were passed, not how many parameters the function declares.
function describe(first, second) {
console.log(arguments.length); // number of values actually passed
console.log(arguments[0]); // same value as first
}
describe("a", "b", "c"); // logs 3, then "a"It is array-like, not an Array
The object has numbered properties and a length property, so it looks like an array, but it is not one. It does not inherit array methods such as map(), filter(), or forEach(). Calling arguments.map(...) throws a TypeError. To use those methods, convert it first with Array.from(arguments) or the spread form [...arguments]. Per the MDN reference for the arguments object, it is also iterable, which is why spread works.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsfunction sumAll() {
const values = Array.from(arguments);
return values.reduce((total, n) => total + n, 0);
}
sumAll(1, 2, 3); // 6Why arrow functions do not get their own arguments
An arrow function is defined without its own arguments binding. The ECMAScript 2015 Language Specification states this directly: “Arrow functions never have an arguments objects.” The same design choice is why arrows do not have their own this. Both names are resolved from the enclosing scope instead.
#1 Best Overall
The practical consequence is that an arrow function inside a regular function can read the outer function’s arguments. The arrow does not see its own call values; it sees the values of whichever regular function it was created inside.
function outer(value) {
const read = () => arguments[0];
return read();
}
outer("hello"); // "hello"This is the reason the restriction is easy to misread. An arrow mentioning arguments is not automatically an error. It is an error only when no enclosing binding exists to resolve the name.
Rank #2
What happens when no outer arguments binding exists
If an arrow refers to arguments and there is no enclosing regular function to supply it, the name is unresolved. In normal function code this produces a ReferenceError. Top-level code is where behavior varies by environment, so the safe rule is not “arrows at the top level always work” or “always fail,” but this: the arrow itself provides nothing, and whether a binding is found depends on the surrounding scope.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →- Arrow inside a regular function: reads the outer function’s
arguments. - Arrow with no enclosing regular function in a plain script or module scope: a bare
argumentsreference is generally unresolved and throws aReferenceError. - Top-level code inside a host wrapper: some hosts run code inside a wrapper function that supplies its own
arguments, so the name may resolve to that wrapper’s values. Check the environment rather than assuming.
Collecting arguments: rest parameters versus arguments
When the goal is to accept any number of values, declare a rest parameter. It is an explicit part of the function signature, it produces a real Array, and it works the same way in regular functions and arrow functions.
const collect = (...args) => args;
collect("a", "b"); // ["a", "b"]| Feature | arguments (regular function) |
Rest parameter ...args |
|---|---|---|
| Available in regular functions | Yes, implicitly | Yes, when declared in the signature |
| Available in arrow functions | No own binding; resolves from outer scope | Yes, declared in the arrow’s parameter list |
| Data type | Array-like object | Real Array |
Array methods such as map() |
Not available without conversion | Available directly |
| Linked to named parameters | Only in non-strict functions with simple parameter lists | Never linked |
| Best use | Reading older code and compatibility | New variadic functions |
The mapped-arguments caveat
Older examples often imply that arguments and named parameters always stay in sync. That holds only for non-strict functions with simple parameter lists. In that case, changing arguments[0] also changes the named parameter. In strict mode, or when a function uses rest parameters, default values, or destructuring, the two are separate.
function sloppy(a) {
arguments[0] = 99;
return a;
}
function strict(a) {
"use strict";
arguments[0] = 99;
return a;
}
sloppy(1); // 99
strict(1); // 1Sources
- MDN Web Docs, “The arguments object – JavaScript,” reference page checked October 2026.
- MDN Web Docs, “Arrow function expressions – JavaScript,” reference page checked October 2026.
- Ecma International, “ECMAScript 2015 Language Specifications, 6th Edition,” published 2015, for the statement that arrow functions never have an arguments object.
No statistics are involved; this is a description of how the language is specified to behave.
Quick Recap
Rank #4
“
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →
