Where is arguments property defined?

Consider the following code

function add(x, y) {
    alert(arguments.length);
    var total = x + y;
    return total;
}
add();  // NaN alerts 0
add(2开发者_JAVA百科,3);  // 5 alerts 2
add(3,3,5);  //6 alerts 3

Where is arguments defined? How come it is available inside my add function?

It is automatically created for all functions.

See https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Functions_and_function_scope/arguments

A detailed explanation about when and how the arguments object is created:

From the ECMAScript specification:

10.1.8 Arguments Object

When control enters an execution context for function code, an arguments object is created and initialised as follows:

• The value of the internal [[Prototype]] property of the arguments object is the original Object prototype object, the one that is the initial value of Object.prototype (see 15.2.3.1).

• A property is created with name callee and property attributes { DontEnum }. The initial value of this property is the Function object being executed. This allows anonymous functions to be recursive.

• A property is created with name length and property attributes { DontEnum }. The initial value of this property is the number of actual parameter values supplied by the caller.

• For each non-negative integer, arg, less than the value of the length property, a property is created with name ToString(arg) and property attributes { DontEnum }. The initial value of this property is the value of the corresponding actual parameter supplied by the caller. The first actual parameter value corresponds to arg = 0, the second to arg = 1, and so on. In the case when arg is less than the number of formal parameters for the Function object, this property shares its value with the corresponding property of the activation object. This means that changing this property changes the corresponding property of the activation object and vice versa.

That is just a standard feature of Javascript. Whenever any function is called, there is an arguments array automatically added to the local scope. This allows a function to receive a variable or unknown amount of parameters from the caller, and dynamically use these as necessary.

Commonly this is used when one function is placed as a wrapper around another where the exact parameters are unknown and arbitrary to the wrapper, who simply performs an action and then passes the provided arguments directly into the wrapped function.

arguments is a property of function objects. See Using the arguments object or Property: Function: arguments for more information.

It's worth noting that arguments is not a "real" array, the documentation calls it an "array-like object" - more in Turning JavaScript's arguments object into an array.