Four call methods of the named Function

Transferred from:Http://snandy.iteye.com/blog/420000

 

1. () parentheses OperatorThe () operator is commonly used to call/execute a function.

JS Code

1. // Fun1
2. Function fun1 (){
3. Alert ('I was called ');
4. }
5. Fun1 ()
7. // Fun2 with Parameters
8. Function fun2 (PARAM ){
9. Alert (PARAM );
10. }
11. Fun2 ('I was called ')

 

After ecmascript3 is added to the function with call and apply, the following two methods are available:

2. Call

JS Code

1. // Fun1
2. Function fun1 (){
3. Alert ('I was called ');
4. }
5. Fun1.call (null );
7. // Fun2 with Parameters
8. Function fun2 (PARAM ){
9. Alert (PARAM );
10. }
11. Fun2.call (null, 'I was called ')

 

3. Apply

JS Code

1. // Fun1
2. Function fun1 (){
3. Alert ('I was called ');
4. }
5. Fun1.apply (null );
7. // Fun2 with Parameters
8. Function fun2 (PARAM ){
9. Alert (PARAM );
10. }
11. Fun2.apply (null, ['I was called'])

 

4. New(This method is not recommended)

JS Code

1. // Fun1
2. Function fun1 (){
3. Alert ('I was called ');
4. }
5. New fun1 ();
8. // Fun2 with Parameters
9. Function fun2 (PARAM ){
10. Alert (PARAM );
11. }
12. New fun2 ('I was called ')

OK. From the above call method, there is no difference in the execution results of the four methods. However, if a function returns a value, calling the new method may disappoint you.

JS Code

1. // Function fun with returned values
2. Function fun (){
3. Alert ('I was called ');
4. Return "Jack ";
5. }
7. VaR c = new fun ();
8. Alert (c); // [object], why not "Jack "?

This is the case,

JS Code

1. // Function fun with returned values
2. Function fun (){
3. Alert ('I was called ');
4. Return {Name: 'jack '};
5. }
7. VaR c = new fun ();
8. Alert (C. Name); // Jack, returns again normally

Summary:

When calling a function using the new method. If a return value exists, this value is not returned when the returned value is a built-in JavaScript type (basic type) such as string, number, or Boolean;

When the returned value is an object, function, array, or other object types, this object, function, and array are returned.

 

When the returned value is a built-in type (basic type), what does new fun () return?

Bytes ----------------------------------------------------------------------------------------------------------------

Whether the function contains this is discussed. If this is not available, an empty object {} is returned. If this is available, a non-empty object is returned.

 

Define a function without this

JS Code

1. // The returned value is of the basic type.
2. Function fun (){
3. Return "Jack ";
4. }
6. VaR c = new fun ();
7. For (VAR recognition in c ){
8. Alert (ASD );
9. }
10. Alert (c); // [object]

The returned value C is not "Jack". It can be seen that C is an empty object {} after the for in statement is executed and no attribute is output {}.

 

Let's take a look at the function with this. The function with this is actually writing a class. However, due to the flexibility of JS, many strange writing methods have been made.

JS Code

1. // The returned value is of the basic type.
2. Function fun (){
3. This. Name = "Tom ";
4. Return "Jack ";
5. }
7. VaR c = new fun ();
8. For (VAR recognition in c ){
9. Alert (ASD); // name
10. }
11. Alert (C. Name); // Tom

The returned value is not "Jack". For in outputs the name attribute. The last sentence outputs Tom, indicating that the returned value C is a non-empty object. The Return "Jack" here does not work at all.

Therefore, when the return value of a function is a built-in type (basic type), calling a function using the new method will result in incorrect results.

 

What if the return value of a function is an object, array, or function?

JS Code

1. // This is not included. The returned value is an object.
2. Function fun (){
3. // Assemble an object
4. VaR OBJ = {};
5. OBJ. Name = 'andy ';
6. OBJ. Age = 20;
7. OBJ. MSG = function (){}
9. Return OBJ;
10. }
12. VaR c = new fun ();
13. For (VAR recognition in c ){
14. Alert (ASD); // name, age, MSG
15. }
16. Alert (C. Name); // Andy

JS Code

1. // Contains this, and the returned value is an object
2. Function fun (){
3. This. Sex = "man ";
4. // Assemble an object
5. VaR OBJ = {};
6. OBJ. Name = 'andy ';
7. OBJ. Age = 20;
8. OBJ. MSG = function (){}
10. Return OBJ;
11. }
13. VaR c = new fun ();
14. For (VAR recognition in c ){
15. Alert (ASD); // name, age, MSG
16. }
17. Alert (C. Name); // Andy

The output results of the two segments are the same. C contains the name, age, and MSG attributes, but not the sex attributes. It indicates that when the returned value is an object type (object, array, function), new will not use this to construct the object, but will directly return the assembled object.

 

This method is actually a factory method. In applications, more programmers write the first letter of the function name to make it look more like a class.

 

The first letter of the function name is capitalized to conform to the Java class naming rules.

JS Code

1. /**
2. * Define a function car
3. */
4. Function car (color, doors ){
6. VaR car = {};
7. Car. Color = color;
8. Car. Doors = doors;
9. Car. MSG = function (){
10. Alert ("this is a" + this. color + "car, there are" + this. Doors + "doors .");
11. }
13. Return car;
14. }

It looks strange. Car is clearly a class, and it is not like the previous function call. It seems a little different from the article title. But we can use () to call it. You can also use new to call it. Use the new method to make it more like the Java object creation method.

JS Code

1. // Method 1
2. VaR C1 = car ('red', 2 );
3. C1.msg ();
5. // Method 2
6. VaR C2 = new car ('black', 4 );
7. C2.msg ();

This method can also be seen in some JS libraries. For example, a very important function native in mootools. JS, the return value is a function (class ). The class in mootools core is returned by the native function. VaR class = new Native ({...}); of course, you can also directly use () for calling without using new.