JavaScript learning tips: The difference between call and apply

1. call
call method
Call a method of an object to replace the current object with another object.
call([thisObj[,arg1[, arg2[, [,.argN]]]]])
Parameters
thisObj
Optional. The object that will be used as the current object.
arg1, arg2, , argN
Optional. A sequence of method parameters will be passed.
Description
The call method can be used to call a method instead of another object. The call method changes the object context of a function from the initial context to the new object specified by thisObj.
If the thisObj parameter is not provided, the Global object is used as thisObj.
Simple example (function call):

function add(a,b) 
{ 
alert(a+b); 
} 
function sub(a,b) 
{ 
alert(a-b); 
} 
add.call(sub,3,1);

This example means using add to replace sub, add.call(sub,3,1) == add(3,1), so The running result is: alert(4); A more complicated example (method call):

function Class1() 
{ 
this.name = "class1"; 
this.showNam = function() 
{ 
alert(this.name); 
} 
} 
function Class2() 
{ 
this.name = "class2"; 
} 
var c1 = new Class1(); 
var c2 = new Class2(); 
c1.showNam.call(c2);

Note that call means to put the method of c1 on c2 for execution. It turns out that c2 does not have a showNam() method. Now we put the showNam() method of c1 on c2 for execution, so this.name should be class2, and the result of execution is: alert ("class2");
Implement inheritance

function Class1() 
{ 
this.showTxt = function(txt) 
{ 
alert(txt); 
} 
} 
function Class2() 
{ 
Class1.call(this); 
} 
var c2 = new Class2(); 
c2.showTxt("cc");

In this way Class2 Inherited Class1, Class1.call(this) means to use the Class1 object instead of this object, then Class2 does not have all the properties and methods of Class1, the c2 object can directly call the methods and properties of Class1, the execution result That is: alert ("cc");
Yes, that's it. This is how javaScript simulates inheritance in object-oriented, and can also implement multiple inheritance.

Multiple inheritance

function Class10() 
{ 
this.showSub = function(a,b) 
{ 
alert(a-b); 
} 
} 
function Class11() 
{ 
this.showAdd = function(a,b) 
{ 
alert(a+b); 
} 
} 

function Class2() 
{ 
Class10.call(this); 
Class11.call(this); 
}

It’s very simple, use two calls to achieve multiple inheritance
Of course, there are other methods of js inheritance, such as using the prototype chain, this is not part of this article Category, I just explain the usage of call here
I mentioned call, and of course apply. These two methods basically mean the same thing
The difference is that the second parameter of call can be of any type, while the second parameter of apply The two parameters must be arrays

2, apply

The functions of apply and call are the same, but there are differences in parameters between the two.
The meaning of the first parameter is the same, but for the second parameter:
apply passes in a parameter array, that is, multiple parameters are combined into an array and passed in, and call is used as call Parameters are passed in (starting with the second parameter).
For example, the corresponding apply writing method of func.call(func1,var1,var2,var3) is: func.apply(func1,[var1,var2,var3])

Tips (the code is elegant and its execution efficiency High)

alert(Math.max(5,8)) //8 
alert(Math.max(5,7,9,3,1,6)) //9 

var arr=[5,7,9,1] 
alert(Math.max.apply(null,arr));

For more JavaScript learning tips on the differences between call and apply, please pay attention to the PHP Chinese website!