Utilisation 1 (usage courant) :
L'expression est : un object.method.call (un autre objet), ce qui signifie remplacer l'objet actuel par un autre objet et exécuter la méthode de l'objet actuel. Regardons d'abord l'exemple :
Copiez le code comme suit :
fonction Classe1(){
this.name = "classe1" ;
this.showName = fonction(){
alert(ce.nom);
}
}
fonction Classe2(){
this.name = "classe2" ;
}
var c1 = nouvelle Classe1();
var c2 = nouvelle Classe2();
c1.showName.call(c2);
c2.showName(); //Ne peut pas être exécuté
Nous avons d'abord défini deux fonctions respectivement, à savoir Class1 et Class2. La principale différence entre elles est que Class2 a une méthode showName() de plus que Class1. Ensuite, les objets c1 et c2 correspondant à Class1 et Class2 sont définis. A ce stade, nous savons clairement que c1 a la méthode showName() mais pas c2. Mais un miracle s'est produit. Lorsque nous exécutons c1.shoName.call(c2), la valeur du nom de c2 apparaîtra, qui est "class2". En fait, nous exécutons toujours les méthodes de c1, mais nous avons juste remplacé temporairement l'objet c2 par l'objet c1. Après l'exécution, elles sont toujours les mêmes qu'au moment de leur définition, et c2 n'a plus de méthodes. Afin de détecter si c2 a plus de méthodes, l'exemple ajoute la ligne c2.showNmae(); Il ne peut pas être exécuté et le navigateur signalera l'erreur Object #<Class2> has no method 'showName'.
Pourquoi faire ça ? Comme mentionné précédemment, il s'agit d'une méthode d'utilisation temporaire, nous l'utilisons simplement pour une programmation efficace. Mais cela n'est pas sans limites. Supposons que c1 et c2 soient utilisés pour représenter l'objet remplacé et l'objet de remplacement, et que fun1 soit utilisé pour représenter la méthode inhérente de c1. 1. Lorsque fun1 ne nécessite pas de paramètres et n'utilise aucune variable locale dans la fonction parent, il n'y a en fait aucune différence entre c1.fun1.call(c2) et c1.fun1(); 2. Lorsque fun1 ne nécessite pas de paramètres mais utilise les variables de la fonction parent, il est alors nécessaire de générer les variables utilisées par fun1 avec les mêmes noms dans les fonctions de c1 et c2; 3. Lorsque fun1 nécessite des paramètres, le formulaire doit être réécrit comme c1.fun1.call(c2 , paramètre 1, Paramètre 2, ...paramètre n), à ce stade, le nom de la variable dans la fonction qui génère c1 ne doit pas nécessairement avoir le même nom que le nom de la variable dans la fonction qui génère c2, il doit seulement correspondre. En fait, lorsque nous utilisons call, c2 et c1 ont souvent de grandes similitudes en termes de structure et de fonction, les trois points ci-dessus sont donc faciles à éviter.
Deuxième utilisation :
Utilisé pendant le processus de définition de la fonction, sous la forme de : une autre fonction existante.call(this), qui peut cloner toutes les variables et méthodes d'une autre fonction existante dans sa propre fonction, obtenant ainsi une fonction similaire à l'héritage. Regardons un exemple :
Copiez le code comme suit :
fonction Animal(nom){
this.name = nom ;
this.showName = fonction(){
alert(this.name);
}
} ;
var animal = new Animal("small_animal");
animal.showName(); //alerte("petit_animal")
fonction Chat(nom){
Animal.call(ce, nom);
} ;
//var Animal = null; //Décommentez et essayez
var chat = nouveau chat("black_cat");
cat.showName(); //alerte("chat_noir")