Tout d'abord, il faut dire que ce pointage ne peut pas être déterminé lorsque la fonction est définie. Ce n'est que lorsque la fonction est exécutée peut être ce point à ce que ce point est. En fait, cela indique finalement l'objet qui l'appelle (il y a des problèmes dans cette phrase, et nous expliquerons pourquoi il y a des problèmes plus tard. Bien que la plupart des articles sur Internet disent cela, bien qu'il n'y ait aucun problème à le comprendre comme cela dans de nombreux cas, il est en fait inexact de le comprendre, donc vous sentirez que vous ne pouvez pas le comprendre lorsque vous comprenez cela). Ensuite, je discuterai de cette question en profondeur ensuite.
Pourquoi apprendre cela? Si vous avez appris la programmation fonctionnelle et la programmation orientée objet, vous devez savoir quoi faire. Si vous ne l'avez pas appris, vous n'avez pas à lire cet article pour le moment. Bien sûr, si vous êtes intéressé, vous pouvez également le lire. Après tout, c'est quelque chose qui doit être maîtrisé dans JS.
Exemple 1:
fonction a () {var user = "Little J"; console.log (this.user); // Console non défini.log (this); // fenêtre} a ();Selon ce que nous avons dit ci-dessus, cela indique finalement l'objet qui l'appelle. La fonction a ici est en fait indiquée par l'objet Window, et le code suivant peut le prouver.
fonction a () {var user = "Little J"; console.log (this.user); // Console non défini.log (this); } window.a () // fenêtreTout comme le code ci-dessus, Alert est en fait une propriété de Window, et il est également signalé par fenêtre.
Exemple 2:
var o = {utilisateur: "Chasing Dreams", fn: function () {console.log (this.user); // Chasing Dreams}} o.fn ();Cela indique ici l'objet O, parce que vous appelez cela FN et l'exécutez via O.Fn (), donc le pointage naturel est l'objet o. Je voudrais souligner à nouveau ici que ce pointage ne peut pas être décidé lorsque la fonction est créée, et elle ne peut être décidée que lorsqu'elle est appelée. Celui qui l'appelle indiquera à qui vous devez comprendre cela.
En fait, l'exemple 1 et l'exemple 2 ne sont pas assez précis. L'exemple suivant peut renverser la théorie ci-dessus.
Si vous voulez bien comprendre cela, vous devez regarder les prochains exemples.
Exemple 3:
var o = {utilisateur: "Catching Dreams", fn: function () {console.log (this.user); // Catching Dreams}} window.o.fn ();Ce code est presque le même que le code ci-dessus, mais pourquoi cela indique-t-il la fenêtre? Si vous suivez la théorie ci-dessus, ce point vers l'objet qui l'appelle. Permettez-moi de dire autre chose ici. Windows est un objet global dans JS. La variable que nous créons ajoute en fait des attributs à la fenêtre, vous pouvez donc utiliser la fenêtre pour pointer l'objet O ici.
Je n'expliquerai pas pourquoi ce code ci-dessus ne pointe pas vers la fenêtre. Regardons un autre code.
var o = {a: 10, b: {a: 12, fn: function () {console.log (this.a); // 12}}} obfn ();Ceci est également souligné par l'objet O, mais cela ne l'exécute pas, donc vous diras certainement que ce que j'ai dit au début est tout faux? En fait, ce n'est pas le cas, c'est juste qu'il était inexact au début. Ensuite, j'ajouterai une phrase. Je crois que vous pouvez bien comprendre le problème auquel cela pointe.
======================================================================================.
Cas 1 : S'il y a cela dans une fonction, mais il n'est pas appelé par un objet au niveau précédent, cela pointe vers la fenêtre. Ce qui doit être expliqué ici, c'est que dans la version stricte de JS, cela pointe vers la fenêtre, mais nous ne discuterons pas du problème de la version stricte ici. Si vous voulez savoir, vous pouvez rechercher en ligne par vous-même.
======================================================================================.
Cas 2 : S'il y a cela dans une fonction et que cette fonction est appelée par un objet au niveau précédent, cela pointe vers l'objet au niveau précédent.
======================================================================================.
Cas 3: S'il y a cela dans une fonction, cette fonction contient plusieurs objets. Bien que cette fonction soit appelée par l'objet le plus extérieur, cela ne pointe que l'objet au niveau suivant. L'exemple 3 peut prouver que si vous ne le croyez pas, continuons à examiner quelques exemples ensuite.
var o = {a: 10, b: {// a: 12, fn: function () {console.log (this.a); // Undefined}}} obfn ();Bien qu'il n'y ait pas d'attribut A dans l'objet B, cela pointe également vers l'objet B, car cela ne fera que pointer son objet précédent, qu'il y ait quelque chose que cela veut dans cet objet.
Il y a un autre cas spécial, exemple 4:
var o = {a: 10, b: {a: 12, fn: function () {console.log (this.a); // Console non défini.log (this); // fenêtre}}} var j = obfn; j ();Cela pointe vers la fenêtre ici, n'est-ce pas un peu confus? En fait, c'est parce que vous ne comprenez pas une phrase, ce qui est également crucial.
Cela indique toujours l'objet qui l'appelle en dernier, ce qui signifie qui l'appelle lorsqu'il est exécuté. Dans l'exemple 4, bien que la fonction FN soit référencée par l'objet B, il n'est pas exécuté lors de l'attribution de FN à la variable J, donc il pointe finalement vers la fenêtre, qui est différent de l'exemple 3. L'exemple 3 exécute directement FN.
Ce n'est en fait que cela, mais le pointage sera différent dans différentes circonstances. Le résumé ci-dessus est une petite erreur à chaque endroit, et il ne peut pas être considéré comme une erreur, mais la situation sera différente dans des environnements différents, donc je ne peux pas l'expliquer clairement immédiatement, vous ne pouvez donc que le ressentir lentement.
Version du constructeur ceci:
fonction fn () {this.user = "small j";} var a = new fn (); console.log (a.user); // petit jLa raison pour laquelle l'objet A peut indiquer l'utilisateur dans la fonction FN ici est parce que le nouveau mot-clé peut modifier la direction de ceci et le pointer vers l'objet a. Pourquoi est-ce que je dis que a un objet? Parce que l'utilisation du nouveau mot-clé est de créer une instance d'objet. Comprenant cette phrase, vous pouvez penser à notre exemple 3. Nous utilisons la variable A pour créer une instance de FN (équivalent à la copie d'un FN dans l'objet a). Pour le moment, il est juste créé et non exécuté. L'appel à cette fonction fn est l'objet a, donc c'est naturellement l'objet a. Alors pourquoi y a-t-il un utilisateur dans l'objet FN? Parce que vous avez copié une fonction FN dans l'objet A, et l'utilisation du nouveau mot-clé équivaut à copier une copie.
En plus de ce qui précède, nous pouvons également changer la direction de nous par nous-mêmes ========= >>> Appeler, postuler, lier
Mettez à jour un petit problème lorsque ces rencontres reviennent
fonction fn () {this.user = 'small j'; retour {}; } var a = new fn; Console.log (A.User); //indéfiniRegardez un autre
fonction fn () {this.user = 'small j'; return function () {};} var a = new fn; Console.log (A.User); //indéfiniRevenir
fonction fn () {this.user = 'small j'; retour 1;} var a = new fn; Console.log (A.User); // petit jfunction fn () {this.user = 'small j'; retour non défini;} var a = new fn; Console.log (A.User); // petit jSi la valeur de retour est un objet, cela pointe vers l'objet retourné. Si la valeur de retour n'est pas un objet, cela pointe toujours vers une instance de la fonction.
fonction fn () {this.user = 'small j'; retour non défini;} var a = new fn; console.log (a); // fn {utilisateur: "Small J"}Un autre point est que bien que Null soit également un objet, cela indique toujours une instance de cette fonction ici, car NULL est plus spécial.
fonction fn () {this.user = 'small j'; return null;} var a = new fn; Console.log (A.User); // petit jPoints de connaissance supplémentaires:
1. La valeur par défaut dans la version stricte n'est plus une fenêtre, mais non définie.
2. Le nouvel opérateur modifiera le problème de pointage de la fonction. Bien que nous l'ayons expliqué ci-dessus, nous n'avons pas discuté de cette question en profondeur. Il est rarement mentionné sur Internet, il est donc nécessaire d'en parler ici.
fonction fn () {this.num = 1;} var a = new fn (); console.log (a.num); // 1Pourquoi cela indique-t-il un? Tout d'abord, le nouveau mot-clé créera un objet vide, puis une méthode d'application de fonction sera automatiquement appelée pour le pointer vers cet objet vide. De cette façon, cette fonction sera remplacée par cet objet vide.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.