The arguments object

When parameters are passed to a function, you can use the arguments object to access information about the parameters passed to your function. Some important aspects of the arguments object include the following:

• The arguments object is an array that includes all the parameters passed to the function.
• The arguments.length property reports the number of parameters passed to the function.
• The arguments.callee property provides a reference to the function itself, which is useful for recursive calls to function expressions.

NOTE: The arguments object is not available if any parameter is named arguments or if you use the ... (rest) parameter.

ActionScript 3.0 allows function calls to include more parameters than those defined in the function definition, but will generate a compiler error in strict mode if the number of parameters is less than the number of required parameters. You can use the array aspect of the arguments object to access any parameter passed to the function, whether or not that parameter is defined in the function definition. The following example uses the arguments array along with the arguments.length property to trace all the parameters passed to the traceArgArray() function:

function traceArgArray(x:int):void
{
     for (var i:uint = 0; i < arguments.length; i++)
    {
         trace(arguments[i]);
    }
}
traceArgArray(1, 2, 3);
// output:
// 1
// 2
// 3

The arguments.callee property is often used in anonymous functions to create recursion. You can use it to add flexibility to your code. If the name of a recursive function changes over the course of your development cycle, you need not worry about changing the recursive call in your function body if you use arguments.callee instead of the function name. The arguments.callee property is used in the following function expression to enable recursion:

var factorial:Function = function (x:uint)
{
     if(x == 0)
{
     return 1;
}
     else
     {
               return (x * arguments.callee(x - 1));
      }
}
trace(factorial(5)); // 120
 

If you use the ... (rest) parameter in your function declaration, the arguments object will not be available to you. Instead, you must access the parameters using the parameter names that you declared for them.
You should also be careful to avoid using the string “arguments” as a parameter name,because it will shadow the arguments object. For example, if the function traceArgArray() is rewritten so that an arguments parameter is added, the references to arguments in the function body refer to the parameter rather than the arguments object. The following code produces no output:

function traceArgArray(x:int, arguments:int):void
{
     for (var i:uint = 0; i < arguments.length; i++)
    {
          trace(arguments[i]);
     }
}
traceArgArray(1, 2, 3);
// no output

The arguments object in previous versions of ActionScript also contained a property named caller, which is a reference to the function that called the current function. The caller property is not present in ActionScript 3.0, but if you need a reference to the calling function, you can alter the calling function so that it passes an extra parameter that is a reference to itself.