introduire
Cela joue un rôle très important dans diverses programmations d'objets et est principalement utilisé pour pointer vers l'objet appelant. Cependant, en JavaScript, les performances sont très différentes, notamment dans différents contextes d'exécution.
De l'article précédent, nous savons qu'il s'agit également d'un attribut dans le contexte d'exécution, il est donc destiné à être indissociable du contexte d'exécution.
Copiez le code comme suit :
activeExecutionContext = {
Voix vocale : {...},
ceci : cetteValeur} ;
En Javascript, la valeur de this dépend du mode d'appel. Il existe quatre modes d'appel : le mode d'appel de méthode, le mode d'appel de fonction, le mode d'appel de constructeur et le mode d'appel d'application.
mode d'appel
Modèle d'appel de méthode
Lorsqu'une fonction est enregistrée en tant que propriété d'un objet, nous l'appelons une méthode. Lorsqu'une méthode est appelée, elle est liée à l'objet, c'est-à-dire que dans le modèle d'appel de la méthode, elle pointe vers l'objet appelant. C’est très facile à comprendre. Vous êtes une de mes méthodes, vous m’appartenez, et bien sûr, cela me désigne.
Copiez le code comme suit :
var monObjet = {
valeur : 0,
incrément : fonction (inc) {
this.value += typeof inc === "numéro" inc : 1;
}
}
monObjet.increment();
console.log(myObject.value); //Sortie : 1
monObjet.increment(3);
console.log(myObject.value); //Sortie : 4
Étant donné que vous pouvez accéder à l'objet auquel vous appartenez via cela, vous pouvez appeler et modifier les propriétés ou les méthodes de l'objet via celui-ci. Comme le montre l'article précédent, ceci, en tant que membre des attributs dans le contexte d'exécution, doit être créé lors de la création du contexte. Toute liaison de this à l'objet se produit au moment de l'appel, qui est un ". liaison différée". Un degré élevé de réutilisation de ces éléments peut être obtenu grâce à une liaison retardée.
Copiez le code comme suit :
fonction showValue(){
console.log(this.value);
}
var a = { valeur : "a"};
var b = { valeur : "b"};
a.showValue = showValue ;
b.showValue = showValue ;
a.showValue(); //Sortie "a"
b.showValue(); //Sortie "b"
La fonction showValue dans l'exemple ci-dessus appartient à la liaison retardée.
modèle d'appel de fonction
Lorsqu'une fonction n'est pas appelée comme méthode d'un objet, il s'agit d'un appel de fonction. En mode d'appel de fonction, ceci est lié à l'objet global. (C'est une erreur dans la conception du langage)
Copiez le code comme suit :
monObjet.double = fonction(){
var ça = ceci; //Solution
var aide = fonction(){
console.log(that, ": ", that.value); //Objet de sortie {valeur : 4, incrément : fonction, double : fonction} ": " 4
console.log(this, ": ", this.value); //Fenêtre de sortie {haut : Fenêtre, fenêtre : Fenêtre…} " : " non défini
}
helper(); //Appeler en tant que fonction
}
Selon le raisonnement normal, comme indiqué dans la quatrième ligne, cela devrait pointer vers l'objet auquel appartient la fonction. Cependant, en raison de problèmes de conception du langage, cela pointe vers l'objet global. Cela rend la situation encore plus mystérieuse et imprévisible. Mais en tant que développeurs, nous ne voulons certainement pas voir cette situation. Heureusement, le remède est également très simple. Dans l’exemple ci-dessus, cela est utilisé pour faire référence à cela. De cette façon, appeler cela dans la méthode d'assistance peut être utilisé comme ceci, ce qui est simple et pratique. Quant au mode d'appel de fonction, la raison pour laquelle il se comporte ainsi sera expliquée en détail plus tard lors de l'analyse du type référence.
Modèle d'appel du constructeur
Étant donné que JavaScript est basé sur l'héritage prototypique, ses concepteurs souhaitent qu'il soit capable de créer des objets via de nouveaux constructeurs comme les langages orientés objet traditionnels, réalisant ainsi une programmation orientée objet. Cela ne semble pas être une bonne idée, et c'est un peu gênant de dessiner un tigre au lieu d'un chien. La première est qu’il est impossible d’apprendre, mais qu’il n’est pas nécessaire d’apprendre. Le mécanisme d'héritage prototypique de JavaScript est déjà très puissant, suffisamment pour répondre au polymorphisme d'héritage requis pour l'orientation objet.
Sans plus tarder, parlons du modèle d’appel du constructeur. Le modèle d'appel du constructeur est très simple. Il consiste à utiliser une fonction en tant que constructeur, puis à l'utiliser pour introduire les propriétés et les méthodes que vous souhaitez rendre publiques. comme suit
Copiez le code comme suit :
function Personne(nom, âge){
this.name = nom ;
this.age = âge;
this.say = fonction(){
console.log("nom : %s, âge : %n", this.name, this.age);
}
}
var p1 = new Person("jink", 24);
p1.say(); //Nom de la sortie : jink, âge : 24
var p2 = nouvelle Personne("Zhang San", 33);
p2.say();//Nom de la sortie : Zhang San, âge : 33 ans
À partir de l'exemple ci-dessus, nous pouvons clairement voir que cela pointe vers l'objet créé via new et le constructeur. Pourquoi cela se produit-il ? En effet, lorsque le constructeur est appelé via new en JavaScript, l'opérateur new appelle la méthode interne [[Construct]] de la fonction "Person", puis, une fois l'objet créé, la méthode interne [[Call]] est appelé. La même fonction "Personne" définit la valeur de ceci sur l'objet nouvellement créé.
appliquer le mode d'appel
Une fois que toutes les fonctions en JavaScript sont créées, elles auront deux méthodes : appliquer et appeler. Je ne veux pas expliquer ici en détail l’utilisation spécifique de ces deux méthodes. Les étudiants qui ne connaissent pas peuvent effectuer une recherche sur Baidu. C’est assez simple. Grâce à deux méthodes, nous pouvons définir cela manuellement. Bien que cela ne puisse pas être modifié lors de la création, si nous le définissons manuellement avant la création, c'est une autre affaire. Ce paramètre est incroyable, vous pouvez faire en sorte que votre objet appelle n'importe quelle méthode, tout comme vous pouvez faire naviguer une voiture dans la mer, un éléphant d'Afrique accélérer comme un jaguar et un programmeur jouer comme un pianiste. Haha, l'imagination est toujours belle. Appeler, c'est appeler, mais savoir si la fonction peut être réalisée après l'appel est une autre affaire.
Copiez le code comme suit :
var programmeur = {
nom : "Programmeur",
main : "mains flexibles",
programme : fonction(){
console.log(this.name+"Écrire le code avec "+this.hand+".");
}
}
var pianiste = {
nom : "pianiste",
main : "mains flexibles",
jouer : fonction(){
console.log(this.name+"Joue de la belle musique avec "+this.hand+".");
}
}
var joueur = {
nom : "athlète",
pied : "Jambes fortes",
exécuter : fonction(){
console.log(this.name+"Utilisez "+this.foot+" pour courir sur le terrain.");
}
}
//Suivez les règles
programmer.programme(); //Les programmeurs écrivent du code avec des mains flexibles.
pianist.play(); //Le pianiste utilise ses mains flexibles pour jouer de la belle musique.
player.run(); //Les athlètes courent sur le terrain avec des jambes fortes.
//capricieux
pianist.play.apply(programmer); //Les programmeurs utilisent leurs mains flexibles pour jouer de la belle musique.
player.run.apply(programmer); //Les programmeurs utilisent undefined pour s'exécuter sur le terrain. Faute d’exercice physique, je n’ai pas de jambes fortes
Cela semble intéressant de voir ci-dessus Le premier paramètre de apply est le pointeur this dans la méthode d'exécution. De cette façon, nous pouvons emprunter les méthodes des autres et les utiliser nous-mêmes en secret, ce qui est extrêmement pratique. Ce type de technique est souvent utilisé dans certains frameworks.
Résumer
C'est tout ce que j'ai à dire à ce sujet. Je pense qu'après avoir lu ceci, tout le monde aura une certaine compréhension de la détermination de ceci dans différentes situations. J'avais initialement prévu de discuter ensuite de l'objet de référence et d'en expliquer la valeur en mode d'appel de méthode. et le principe du mode d'appel de fonction, mais j'avais peur que la longueur soit trop longue, j'ai donc décidé d'utiliser un chapitre séparé pour analyser le concept d'objets de référence.