Detailed explanation of the use of Arguments object in JavaScript

In actual development, the Arguments object is very useful. Flexible use of Arguments objects can improve the flexibility of using functions and enhance the adaptability and error correction capabilities of functions in abstract programming.

Summary of the purpose of the Arguments object in JavaScript.

Preface

I believe many of us have used a special object in the process of code development - the Arguments object.

In actual development, the Arguments object is very useful. Flexible use of Arguments objects can improve the flexibility of using functions and enhance the adaptability and error correction capabilities of functions in abstract programming.

So how should the Arguments object be used? Let’s summarize today.

Basic Concepts of Arguments

Arguments is an array-like object corresponding to the arguments passed to the function.

Arguments is an object that is similar to an array but is not an array. It is similar to an array because it has the same access properties and methods as an array. The value of the corresponding single parameter can be accessed by arguments[n] , and it has an array length attribute. Also, the Arguments object stores the parameters actually passed to the function, and is not limited to the parameter list defined in the function declaration, and the Arguments object cannot be created explicitly.

Here is a simple example of using Arguments:

function func1(a, b, c) {
    console.log(arguments[0]);
    console.log(arguments[1]);
    console.log(arguments[2]);
}

func1(1, 2, 3);
// 1
// 2
// 3

We can directly get the passed parameter set through arguments inside the function, and then get the parameter value of the corresponding position in the form of an array.

The role of arguments

As a special object in JavaScript, what are the uses of Arguments, or how to use it?

Get the number of actual and formal parameters

Use the arguments.length property to get the number of actual parameters of a function. The length property of the function object can be used to obtain the number of formal parameters of the function. This property is a read-only property and can be used both inside and outside the function body.

The following example designs a checkArg() function to check whether the formal and actual parameters of a function are consistent, and throw an exception if they are inconsistent.

function checkArg(a) {
    //Check if the actual parameter and formal parameter of the function are consistent if (a.length != a.callee.length)
        //If the number of actual parameters is different from that of formal parameters, an error is thrown throw new Error("actual parameters and formal parameters are inconsistent");
}

function f(a, b) {
    //Calculate the average of two numbers checkArg(arguments); //Use arguments to check whether the actual and formal parameters of the function are consistent return ((a * 1 ? a : 0) + (b * 1 ? b : 0)) / 2; //Return the average value }
console.log(f(6)); //Throws an exception. Call function f, passing in a parameter

Modify the actual parameter value

In the following example, a for loop is used to iterate over the arguments object, and then the value of the loop variable is passed into arguments to facilitate changing the actual parameter value.

function f() {
    for (let i = 0; i < arguments.length; i++) { //Traverse the arguments object arguments[i] = i; //Modify the value of each actual parameter console.log(arguments[i]); //Prompt the modified actual parameter value}
}

f(3, 3, 6); //Returns prompts 0, 1, 2 instead of 3, 3, 6

Changing the number of arguments

By modifying the length property value, you can also change the number of actual parameters of the function. When the length property value increases, the increased actual parameter value is undefined; if the length property value decreases, the actual parameter value after the length value is discarded.

function f() {
    arguments.length = 2; //Modify the length property value of the arguments property object for (let i = 0; i < arguments.length; i++) {
        console.log(arguments[i]);
    }
}

f(3, 3, 6); //Return prompt 3, 3

Check parameter validity

In the following example, arguments.callee is used to obtain an anonymous function, and then the number of function parameters is obtained through the length property of the function. Finally, the number of actual parameters is compared with the number of formal parameters to check whether the parameters passed by the user meet the requirements.

function f(x,y,z) {
    let a = arguments.length; //Get the number of actual parameters of the function let b = arguments.callee.length; //Get the number of formal parameters of the function if (a != b){ //If the number of actual parameters and formal parameters are not equal, an error message will be prompted throw new Error("The passed parameters do not match");
    }else { //If the number of actual parameters and formal parameters is the same, return their sum return x + y + z;
    }
}

console.log(f(3,4,5)); //Return value 12

arguments.callee is equivalent to the function name. In the above example, arguments.callee is equal to f.

When the number of function parameters is uncertain, it is used to access the actual parameter value of the calling function

If the number of function parameters is uncertain, or the function has a large number of parameters and you do not want to define each formal parameter one by one, you can omit the definition of the parameters and directly use the Arguments object in the function body to access the actual parameter values ​​of the calling function.

The following example defines an average function that uses the arguments object to calculate the average of the parameters. When calling a function, you can pass in any number of parameters.

function avg() {
    //Find the average value let num = 0;
    let length = 0; //Declare and initialize temporary variables for (let i = 0; i < arguments.length; i++) {
        //Traverse all actual parameters if (typeof arguments[i] != "number") {
            //If the parameter is not a numeric value continue; //then ignore the parameter value}
        num += arguments[i]; //Calculate the sum of the numerical values ​​of the parameters length++; //Calculate the number of parameters involved in the sum operation}

    return num / length; //Return the average value}

console.log(avg(1, 2, 3, 4)); //Returns 2.5
console.log(avg(1, 2, "3", 4)); //Returns 2.3333333333333335

Traverse or access the value of the actual parameter

The arguments object is a pseudo-array, not an array. You can traverse or access the value of the actual parameter through the length attribute and the bracket syntax. However, you can also use array methods such as push, pop, slice, etc. through dynamic calling methods.

The following example uses the dynamic calling method to let the arguments object call the array method slice() to convert the function parameter object into an array.

function f() {
    return [].slice.apply(arguments);
    // You can also use the following expression // return Array.from(arguments);
    // return [...arguments];
}
console.log(f(1, 2, 3, 4, 5, 6)); //Returns [1,2,3,4,5,6]

Summarize

The above is a summary of the practical uses of the Arguments object. I hope we can all use Arguments flexibly and write poetic code!

This is the end of this article about the use of the Arguments object in JavaScript. For more information about the use of the Arguments object in JavaScript, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!