Js-arguments's understanding

Js-arguments's understanding Blog Category:

• Web Front end-js language core

Arguments

Zccst



2014-6-10 construct an array like
The constituent points of an array of classes:
1, the element is an array-indexed
2, with the length property

JS Code

1. var test3 = {
2. 0:10,
3. 1: function () {
4. return this[0];
5. },
6. Length:2
7. }
8. Console.log (Array.prototype.slice.call (test3)); //print [Ten, Function ()]

2014-6-9
The function parameter arguments is an array of classes, but not an array. (Arguments is an object)
If you want to turn into a true array, you can
var slice = [].slice;
Slice.call (arguments);
can also: Aarray.prototype.slice.call (arguments);

JS Code

2. var o = {
4. Name:"JavaScript"
6. };
8. var F1 = function () {
10. return 2;
12. }
14. var foo = function (a,b,c) {
16. Console.log (arguments, typeof arguments, $.type (arguments), typeof Arguments.push);
18. //[100, function (), object {name= "JavaScript"}] Object object undefined
22. //Although arguments is not an array, you can still remove each element through a for loop
24. For (var i in arguments) {
26. Console.log (Arguments[i]);
28. }
30. / * Print
32. 100
34. function ()
36. Object {name= "javascript"}
38. */
42. ///Now let the slice of the array run in the context of arguments, the parameter is 0, then the arguments is turned into an array, (arguments itself does not change)
44. var ret = Array.prototype.slice.call (arguments);
48. Console.log (ret, typeof ret, $.type (ret), typeof Ret.push);
50. //[100, function (), object {name= "JavaScript"}] Object Array function
52. }
54. Foo (100,f1,o);

Basic introduction
When JS makes a function call, it creates an implied object--arguments in addition to the specified parameters.
One, arguments can use the arguments[index] such syntax to take the value, has the length of the property lengths. The arguments object stores parameters that are actually passed to the function, not limited to the list of parameters defined by the function declaration, for example:

JS Code

1. function Func (A, b) {
2. alert (a);
3. alert (b);
4. For (var i=0;i<arguments.length;i++) {
5. Alert (Arguments[i]);
6. }
7. }
8. Func (1,2,3,4);

When the code runs, it is displayed in turn: 1,2,1,2,3,4. The function defines two parameters, but passes 4 arguments at the time of the call.

Second, the callee attribute of arguments
It represents a reference to the function object itself, which facilitates recursion of the nameless function or guarantees the encapsulation of the function. For example, the sum of natural numbers from 1 to n is calculated by recursion:

JS Code

1. var sum=function (n) {
2. if (1==n) {
3. return 1;
4. } Else {
5. return n + arguments.callee (n-1);
6. }
7. }
8. Alert (sum (100));

Arguments.callee represents a reference to a function that is currently executing, or a function object that invokes Arguments.callee, which provides an anonymous function with a way of self-referencing.





More in-depth, including caller, call, apply

JS Code

2. /*
4. * Demonstrate the use of arguments, how to get real parameters and number of shapes
6. */
8. function Argtest (a,b,c,d) {
10. var numargs = arguments.length;  //Gets the numeric value of the passed parameter.
12. var expargs = argtest.length;  //Gets the value of the desired parameter.
14. Alert ("real parameter:" +numargs)
16. Alert ("Number of shapes:" +expargs)
20. Alert (Arguments[0])
22. Alert (argtest[0]) //undefined no such usage
24. }
26. Argtest (ON)
28. Argtest (1,2,3,4,5)
34. /*
36. * Arguments not arrays (array Class)
38. */
42. Array.prototype.selfvalue = 1;
44. function testaguments () {
46. Alert ("arguments.selfvalue=" +arguments.selfvalue);
48. }
50. Alert ("Array.sefvalue=" +new Array (). Selfvalue); 1
52. Testaguments (); Arguments.selfvalue = undefined
60. /*
62. * Demonstrates the callee property of a function.
64. * Description: Arguments.callee: The initial value is the function object being executed for the anonymous function
66. */
68. function Calleedemo () {
70. alert (Arguments.callee);
72. }
74. Calleedemo ();
76. (function (ARG0,ARG1) {alert ("Number of shapes:" +arguments.callee.length)}) ();
86. /*
88. * Demonstrates the caller property of a function.
90. * Description: (current function). Caller: Returns a reference to the function that called the current function
92. */
96. function Callerdemo () {
98. if (callerdemo.caller) {
100. var a= callerdemo.caller.arguments[0];
102. alert (a);
104. } Else {
106. Alert ("This is a top function");
108. }
110. }
112. function Handlecaller () {
114. Callerdemo ();
116. }
120. Callerdemo ();
122. Handlecaller ("Parameter 1", "Parameter 2");
134. /*
136. * Demonstrates the use of the Apply,call function
138. * Description: The role is to bind the function to another object to run, the two are only defined in the way the parameters differ:
140. * Apply (Thisarg,argarray);
142. * Call (Thisarg[,arg1,arg2 ...]);
144. * That is, the this pointer inside all functions will be assigned a value of Thisarg
146. */
150. function Objecta () {
152. Alert ("Execute objecta ()");
154. Alert (arguments[0]);
156. Alert (this.b);   The value of the variable B OBJECTB when Objecta is called with call/apply in OBJECTB.
158. this.hit=Function (msg) {alert (msg)}
160. this.info="I'm from Objecta."
162. }
166. function Objectb () {
168. Alert ("Execute OBJECTB ()");
170. this.b = ' 2b ';
172. //Call the Objecta () method, and all this in the Objecta constructor is replaced by this in the OBJECTB
174. Objecta.apply (this,arguments);   Objecta.call (this);
176. Alert (this.info);
178. }
180. //OBJECTB (' parameter 0 ');
186. var value="global variable";
188. function Obj () {
190. this.value="Object!  ";
192. }
194. function Fun1 () {
196. Alert (this.value);
198. }
200. //fun1 ();
202. //fun1.apply (window);
204. //fun1.apply (New OBJ ());
     

Js-arguments's understanding