arguments object in Javascript

Everything in js is an object, even functions are objects. The function name is actually a variable that refers to the function definition object.

1. What are arguments?

The arguments in this function body are very special. They are actually a built-in array-like object of the function in which they are located. You can use the [i] and .length of the array.

2. What is the function?

js syntax does not support overloading! However, the arguments object can be used to simulate the overloading effect.

arguments object: Within the function object, an automatically created array-like object is specially created to receive all parameter values.
arguments[i]: Get the parameter value passed in with subscript i
arguments.length: Get the number of parameters passed in!

Overloading:

Multiple functions with the same function name and different parameter lists can be defined in the program.
The caller does not need to distinguish the parameters of each function.
When executing, the program automatically determines which function to select for execution based on the number of parameters passed in.

The example is as follows:

// 1、如果用户传入一个参数，求平方
function sum(a){
console.log(a*a);
}
//如果用户传入两个参数，就求和
function sum(a,b){
console.log(a+b);
}
sum(4); //？
sum(4,5); //？

The original intention of the above example is to let the function sum() with the same name output different results according to different parameters, but sum is the name of the function and is essentially a variable,

The second one will overwrite the first one, so the correct output answer above is: NaN,9. So this is obviously not possible.

It’s much simpler if you use arguments.

The following two examples:

//2、
function calc(){
//如果用户传入一个参数，求平方
if(arguments.length==1){
console.log(arguments[0]*arguments[0]);
}else if(arguments.length==2){
//如果用户传入两个参数，就求和
console.log(arguments[0]+arguments[1]);
}
}
calc(4); //16
calc(4,5); //9 
/*3、无论用户传入几个数字，都可以求和*/
function add(){
//arguments:[]
//遍历arguments中每个元素，并累加
for(var i=0,sum=0;i<arguments.length;sum+=arguments[i++]);
return sum;//返回和
}
console.log(add(1,2,3)); //6
console.log(add(1,2,3,4,5,6)); //21

This is the effect of JS using arguments overloading. A simple understanding is that a function is reused.

arguments. The length is determined by actual parameters, that is, the number of parameters in the function call is determined!

The above is the knowledge about the arguments object in Javascript introduced by the editor. I hope it will be helpful to you. If you have any questions, please leave me a message and the editor will reply in time. Ours. I would also like to thank you all for your support of the PHP Chinese website!

For more articles related to the arguments object in Javascript, please pay attention to the PHP Chinese website!