Detailed explanation of JavaScript built-in object arguments

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

format(“And the %1 want to know whose %2 you %3″, ”papers”, ”shirt”, ”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);

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)));   
  };   
}

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.”);

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

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.”

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);   
    }   
  };   
}

I have a super simple function that carries a string and executes the alert method.

function comms(s) {  
  alert(s);  
}

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

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