Home > Web Front-end > JS Tutorial > body text

Detailed explanation of JavaScript built-in object arguments

高洛峰
Release: 2016-12-14 09:03:31
Original
1620 people have browsed it

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. So 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 in 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.

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];   
  });  
};
Copy after login

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.

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

The above code will return: And the papers want to know whose shirt you wear" .

One thing we need to pay attention to is that when defining the function, we only specify one parameter, string. Javascript allows us to pass any number of parameters into a function, no matter how the function is defined. The Arguments object is allowed for these.
3. Convert the arguments object into a real array
Although the arguments object is not a real javascript array, we can still do it. Easily convert it into standard data and then perform array operations.

var args = Array.prototype.slice.call(arguments);
Copy after login

Then the variable args now contains a standard JavaScript array object containing all the parameters of the function.

Four. Create the function
Arguments object through the preset arguments object. Allows us to execute all types of javascript methods. Attached 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. Provides the parameters that accompany the anonymous function call.

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)));   
  };   
}
Copy after login

The first argument object provides makeFunc with a reference to the function you want to call. It is then removed from the arguments array and returns an anonymous function to run. The specified method.

The first applied argument points to the scope of the function call, which is mainly the key part inside the function. We first keep this as null. The second argument is an array and will be converted into arguments for this function. Object. makeFunc concatenates the original array value into the arguments object provided to the anonymous function and the array of the called function.
You need to output a template at the same position so that it does not have to be called every time the template is referenced. format function. You can use the general function of makeFunc to return a function that can call format and automatically complete the template.

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

You can call the majorTom function like this:

majorTom(“stepping through the door”);   
majorTom(“floating in a most peculiar way”);
Copy after login

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

“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.”
Copy after login

5. Create a function that references itself

You may think this is cool, but arguments has more surprises. It has other useful features: callee method. Arguments.callee includes a reference to a function to create an argument 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.

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);   
    }   
  };   
}
Copy after login

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.

function comms(s) {  
  alert(s);  
}
Copy after login

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

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

call the somethingWrong function. The result is to repeat this action three times, with an interval of 2 seconds between each alert.

Although Arguments is not used often and is a bit weird, it is full of surprises and is worth understanding.

Related labels:
source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template