Comparaison de l'utilisation de la méthode d'appel et de la méthode d'application dans les connaissances JavaScript_Basic

Définition de la méthode
méthode d'appel :
Syntaxe : call([thisObj[,arg1[, arg2[, [,.argN]]]]])
Définition : Appelez une méthode d'un objet pour remplacer l'objet actuel par un autre objet.
Descriptif :
La méthode call peut être utilisée pour appeler une méthode au nom d’un autre objet. La méthode d'appel modifie le contexte d'objet d'une fonction du contexte initial au nouvel objet spécifié par thisObj.
Si le paramètre thisObj n'est pas fourni, l'objet Global est utilisé comme thisObj.

Méthode d'application :
Syntaxe : apply([thisObj[,argArray]])
Définition : Appliquer une méthode d'un objet pour remplacer l'objet actuel par un autre objet.
Descriptif :
Si argArray n'est pas un tableau valide ou n'est pas un objet arguments, une TypeError sera provoquée.
Si ni argArray ni thisObj ne sont fournis, l'objet Global sera utilisé comme thisObj et aucun paramètre ne pourra être transmis.

Exemples courants
un、

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

Cet exemple signifie remplacer sub par add, add.call(sub,3,1) == add(3,1), donc le résultat en cours d'exécution est : alert(4); // Remarque : in js ; La fonction est en fait un objet et le nom de la fonction est une référence à l'objet Function.

b.

function Animal(){ 
 this.name = "Animal"; 
 this.showName = function(){ 
  alert(this.name); 
 } 
} 
 
function Cat(){ 
 this.name = "Cat"; 
} 
 
var animal = new Animal(); 
var cat = new Cat(); 
 
//通过call或apply方法，将原本属于Animal对象的showName()方法交给对象cat来使用了。 
//输入结果为"Cat" 
animal.showName.call(cat,","); 
//animal.showName.apply(cat,[]); 

call signifie mettre la méthode animal sur cat pour exécution. À l'origine, cat n'avait pas de méthode showName() Maintenant, la méthode showName() de animal est mise sur cat pour exécution, donc this.name devrait être Cat
.
c. Mettre en œuvre l'héritage

function Animal(name){  
 this.name = name;  
 this.showName = function(){  
  alert(this.name);  
 }  
}  
 
function Cat(name){ 
 Animal.call(this, name); 
}  
 
var cat = new Cat("Black Cat");  
cat.showName(); 

Animal.call(this) signifie utiliser l'objet Animal à la place de cet objet. Alors Cat n'a-t-il pas toutes les propriétés et méthodes d'Animal ? L'objet Cat peut appeler directement les méthodes et propriétés d'Animal.
d. Héritage multiple

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

C'est très simple, utilisez deux appels pour obtenir un héritage multiple

Bien sûr, il existe d'autres moyens d'hériter de js, comme l'utilisation de la chaîne de prototypes. Cela n'entre pas dans le cadre de cet article. J'explique simplement l'utilisation de call ici. En parlant d'appel, et bien sûr d'appliquer, ces deux méthodes signifient fondamentalement la même chose. La différence est que le deuxième paramètre de call peut être de n'importe quel type, tandis que le deuxième paramètre de apply doit être un tableau, ou il peut s'agir d'arguments <.>
Les méthodes call et apply en JavaScript sont principalement utilisées pour changer le contexte de l'objet fonction, c'est-à-dire le contenu pointé par celui-ci dans la fonction.

La méthode d'appel est la suivante :

fun.call(obj1, arg1, arg2, ...);
fun.apply(obj2, [arrs]);

Exemple spécifique :

var Obj1 = {
 name: 'Object1',
 say: function(p1, p2) {
  console.log(this.name + ' says ' + p1 + ' ' + p2);
 }
};

// logs 'Object1 says Good morning'
Obj1.say('Good', 'morning');

var Obj2 = {
 name: 'Object2'
};

// logs 'Object2 says Good afternoon'
Obj1.say.call(Obj2, 'Good', 'afternoon');

// logs 'Object2 says Good afternoon again'
Obj1.say.apply(Obj2, ['Good', 'afternoon again']);

Comme le montre l'exemple, lors d'un appel via la méthode conventionnelle, ceci dans la méthode pointe vers Obj1, mais lors d'un appel via call et apply, cela pointe vers Obj2.

Comme le montre l'exemple, les fonctions call et apply sont exactement les mêmes, et la différence dans leurs méthodes d'appel réside uniquement dans la liste des paramètres.