Ma compréhension de cela a toujours été de pouvoir l'utiliser et le savoir, mais je n'ai pas plongé dans son essence. Cette fois, j'ai une compréhension profonde avec "Javascript les bonnes parties". (Tout débogage peut être vu dans la console, touche F12 du navigateur)
Jetons un coup d'œil à ceci ensemble.
Lorsque nous déclarons une fonction, chaque fonction a deux paramètres supplémentaires (paramètres formels) définis, l'un est celui-ci et l'autre est des arguments. Les arguments sont les paramètres réellement acceptés par la fonction et sont un tableau de classes. Je ne ferai qu'une brève introduction aux arguments, et nous nous concentrerons sur ce pointeur.
Dans la transformation orientée objet, cela est très important et sa valeur dépend du modèle de l'appel. Dans JavaScript, il y a 4 modèles d'appel dans le total: modèles d'appel de méthode, modèles d'appel de fonction, modèles d'appel de constructeur et appliquent des modèles d'appel.
Mode d'appel de méthode
Lorsqu'une fonction est un attribut en tant qu'objet, nous appelons généralement cette fonction une méthode de cet objet. Lorsque cette méthode est appelée, cela pointe vers l'objet auquel appartient la méthode.
La copie de code est la suivante:
<script type = "text / javascript">
var peuple = {
Nom: "Yika",
SayName: function () {
console.log (this.name); // "Yika"
// cela a été lié à l'objet des gens
}
}
People.SayName ();
</cript>
Comme le montre le châtaignier, cela pointe vers l'objet SayName. Cette méthode d'obtention du contexte de l'objet à travers cela est une méthode publique. (Méthode Publice)
Mode d'appel de fonction
Lorsqu'une fonction est appelée n'est pas une méthode sur un objet, elle est appelée en fonction.
Cet appel de modèle pointera vers l'objet Window, même si cette fonction peut être appelée dans une fonction externe, regardons-la.
La copie de code est la suivante:
<script type = "text / javascript">
var name = "window-yika";
var peuple = {
Nom: "People-yika",
étudiant: function () {
console.log (ceci); // cela lie les gens de l'objet ici
fonction ditName () {
var name = "sayname-yika";
console.log (this.name); // Window-yika
// Même si la fonction SayName elle-même et que les gens s'opposent à laquelle il est situé a une valeur de nom, cela pointe vers la fenêtre
};
SayName ();
}
}
People.Student ();
</cript>
De ce point de vue, savez-vous comment résoudre le JavaScript "Erreur de conception".
Oui, cachez-le simplement dans la fonction étudiante, c'est-à-dire la ligne 6. ensuite transférez-le à la fonction SayName à travers les variables pour le résoudre!
La copie de code est la suivante:
var peuple = {
Nom: "People-yika",
étudiant: function () {
var self = this; // Cache ceci
fonction ditName () {
var name = "sayname-yika";
console.log (self.name); // "People-yika", à l'heure
};
SayName ();
}
}
Mode d'appel du constructeur
Lorsque JavaScript parle de constructeurs, vous penserez: "Le nom de la fonction est capitalisé! Utilisez le nouvel opérateur lorsque vous appelez!" Le nom de fonction La capitalisation est facile à comprendre, afin de standardiser la dénomination du constructeur. Mais avez-vous déjà expliqué pourquoi vous devez utiliser de nouveaux? Si vous appelez une nouvelle fonction avec une nouvelle, l'arrière-plan de la fonction créera un nouvel objet pointant vers le prototype de fonction, et cela est également lié au nouvel objet. JavaScript est un langage basé sur l'héritage prototype. Les étudiants qui ne sont pas très clairs sur les prototypes prototypes peuvent vérifier les informations par eux-mêmes. Je me concentre sur cela.
Voyons d'abord à quoi ressemble le constructeur.
La copie de code est la suivante:
<script type = "text / javascript">
fonction des gens (nom) {
this.name = name; // cela ici pointe vers le nouvel objet Yika après l'avoir appelé avec un nouveau
this.sayName = function () {
console.log (this.name); //Sortir
}
}
var yika = de nouvelles personnes ("yika");
Yika.sayName (); // Sortie "Yika" Parce que Yika est obtenue via un nouvel appel, ceci est lié à l'objet Yika.
</cript>
À première vue, il semble qu'il ne soit pas facile à comprendre. Pourquoi cela a-t-il indiqué la fenêtre de la fonction tout à l'heure, et maintenant vous pouvez indiquer que les gens fonctionnent sans cache?
Cela n'a pas d'importance. N'avez-vous pas simplement dit que la fonction fera «faire de mauvaises choses» secrètement en appelant nouveau? Voyons ce que vous avez fait exactement.
La copie de code est la suivante:
<script type = "text / javascript">
fonction des gens (nom) {
var that = {}; // Mauvaise chose: générez un objet par vous-même
that.name = name;
that.sayName = function () {
console.log (that.name);
};
retourner cela; // Mauvaise chose 2, vous changerez le comportement du retour, renvoie l'objet qui vient d'être généré
}
var yika = People ("yika"); // Nouveau peut être omis ici et imiter l'appel au nouvel opérateur
Yika.sayName (); // Sortie "Yika" comme maintenant
</cript>
Vous pouvez voir clairement de cette façon. New générera non seulement un objet, mais renvoie également automatiquement l'objet, de sorte que cela pointera naturellement vers ce nouvel objet.
N'oubliez pas d'utiliser un nouveau pour appeler le constructeur, sinon il n'y aura aucun avertissement en cas de problème, et tous les accords en capital sont toujours très nécessaires.
Appliquer le mode d'appel
La méthode d'application nous permet de créer un tableau de paramètres transmis à la fonction d'appel, ce qui nous permet également de modifier cette valeur.
function.Apply (cette valeur liée, argument Arrayeter)
Il y a tellement de choses que je peux dire, je ne vous donnerai qu'un châtaignier ici pour vous aider à comprendre:
La copie de code est la suivante:
<script type = "text / javascript">
fonction des gens (nom) {
this.name = name;
this.sayName = function () {
console.log (this.name); // La méthode SayName appartient au constructeur du peuple
}
}
fonction Student (name) {
People.Apply (ceci, arguments); // La méthode d'intégration de l'emprunt des constructeurs est d'appeler les constructeurs de personnes en postulant dans le constructeur étudiant et en modifiant la population de cette valeur
// De cette façon, chaque fois qu'une instance d'étudiant est créée, le constructeur du peuple sera appelé
}
Var Student = New Student ("Yika");
Student.SayName (); // Sortie "Yika"
</cript>
Nous pouvons facilement modifier l'objet de liaison de la fonction via Appliquer. L'appel similaire à appliquer a également le même effet. Les étudiants intéressés peuvent rechercher et l'apprendre par eux-mêmes.
Eh bien, nous avons finalement fini de changer les quatre modes d'appel de cela. Le mode d'appel de méthode et le mode d'appel du constructeur seront plus utilisés, et il sera plus important. Pour le mode d'appel de fonction, nous devons apprendre à éviter les pièges.
S'il y a une erreur, veuillez le signaler à temps et je le corrigerai dès que possible pour éviter les autres en erreur. Merci!