Detailed explanation of JavaScript built-in object arguments_Basic knowledge

1. What are arguments
arguments is a built-in object in JavaScript. It is weird and often overlooked, but it is actually very important. All major JavaScript libraries utilize the arguments object. Therefore, the agruments object must be familiar to JavaScript programmers.
All functions have their own arguments object, which contains the parameters to be called by the function. It is not an array. If typeof arguments are used, 'object' is returned. Although we can call arguments using the method of calling data. For example, length and index methods. But array push and pop objects are not applicable.
2. Create a flexible function
It seems that the argument object is very limited to use, but in fact it is a very useful object. You can enable a function to be called with a variable number of arguments by using the argument object. There is a formatting function in Dean Edwards' base2 library that demonstrates this flexibility.

Copy code The code is as follows:

function format(string) {
var args = arguments;
var pattern = new RegExp(“%([1-" arguments.length "])”, ”g”);
return String(string).replace(pattern, function(match, index) {
Return args[index];
});

};

We provide a template string, you can use "%1" to "%9" to add a placeholder to the return value. Nine other parameters are then provided for insertion.

Copy code The code is as follows:

format(“And the %1 want to know whose %2 you % 3″, “papers”, “shirt”, “wear”);

The above code will return: And the papers want to know whose shirt you wear" .
There is one thing we need to pay attention to , when defining the function, we only specify one parameter, string. Javascript allows us to pass any number of parameters to a function, no matter how the function is defined. The Arguments object allows these. The arguments object is converted into a real array
Although the arguments object is not a real javascript array, we can easily convert it into standard data and then perform array operations. 🎜>
Copy code

The code is as follows:var args = Array.prototype.slice.call(arguments); Then now this variable args It contains a standard JavaScript array object containing all the parameters of the function. Fourth, create a function through the preset arguments object

The Arguments object allows us to execute all types of JavaScript methods. Here is the definition of a makeFunc function. . This function allows us to provide a function reference and all parameters of this function. It will return an anonymous function to call the function you specify, and also provide the parameters when the anonymous function is called. >

Copy code


The code is as follows:

function makeFunc() { var args = Array.prototype.slice.call(arguments); var func = args.shift(); return function() { return func.apply(null, args.concat(Array.prototype.slice.call(arguments))); } ; }

The first argument object provides makeFunc with a reference to the function you want to call. It is removed from the arguments array. Then makeFunc returns an anonymous function to run the specified method.
The first applied argument points to the scope of the function call, mainly to the key parts inside the function. Let's keep this null for now. The second arguments is an array, which will be converted into an arguments object for this function. makeFunc concatenates the original array values ​​into the arguments object and provides the arrays to the anonymous function and the called function.
You need to always output a template at the same position, so that you don't have to always call the format function every time the template is referenced. You can use the generic functionality of makeFunc to return a function that calls format and then automatically completes the template.

Copy code

The code is as follows:

var majorTom = makeFunc(format, “This is Major Tom to ground control . I'm %1.”);

You can call the majorTom function like this:

Copy the code The code is as follows:

majorTom("stepping through the door");
majorTom("floating in a most peculiar way");

Every time you call majorTom, it will call both the format function and the first argument, the template that has been written . Then it will return

Copy code The code is as follows:

“This is Major Tom to ground control. I'm stepping through the door."
"This is Major Tom to ground control. I'm floating in a most peculiar way."

5. Create a function that references itself
You may think this is very strange Cool, but the arguments have more surprises. It has other useful features: the callee method. Arguments.callee contains a reference to a function to create an arguments object. So how to use it?
The Arguments.callee method allows an anonymous function to point to itself conveniently.
Repeat is a function that carries a function reference and two numbers. The first number is the number of times the function is called, and the second number is the time between each call, in milliseconds.

Copy code The code is as follows:

function repeat(fn, times, delay) {
return function () {
if(times– > 0) {
fn.apply(null, arguments);
var args = Array.prototype.slice.call(arguments);
var self = arguments.callee;
setTimeout(function(){self.apply(null,args)}, delay);
}
};
}

The Repeat function uses the arguments.callee method to obtain a reference from the variable self, pointing to the function that ran the original instruction. This way the anonymous function can call itself again.
I have a super simple function that carries a string and executes the alert method.

Copy code The code is as follows:

function comms(s) {

alert(s);

}

However, I want to create a special version through which I can repeat this action three times, each time with 2 seconds interval. Then, we can

Copy code The code is as follows:

var somethingWrong = repeat(comms, 3, 2000) ;
somethingWrong(“Can you hear me, major tom?”);

The result of calling the somethingWrong function is to repeat this action three times, with an interval of 2 seconds between alerts.
Although Arguments is not used often and is a bit weird, it is full of surprises and is worth understanding.