Zunächst muss gesagt werden, dass dieser Zeigungsvermögen nicht bestimmt werden kann, wenn die Funktion definiert ist. Nur wenn die Funktion ausgeführt wird, kann dieser Punkt auf wen dieser Punkt sind. Tatsächlich weist dies letztendlich auf das Objekt hin, das es nennt (es gibt einige Probleme in diesem Satz, und wir werden später erklären, warum es später Probleme gibt. Obwohl die meisten Artikel im Internet dies sagen, obwohl es in vielen Fällen kein Problem beim Verständnis des Verständnisses gibt, ist es tatsächlich unkorrekt, es zu verstehen, damit Sie es nicht herausfinden können, wenn Sie dies verstehen. Dann werde ich dieses Problem als nächstes diskutieren.
Warum das lernen? Wenn Sie funktionale Programmierung und objektorientierte Programmierung gelernt haben, müssen Sie wissen, was zu tun ist. Wenn Sie es nicht gelernt haben, müssen Sie diesen Artikel vorerst nicht lesen. Wenn Sie interessiert sind, können Sie es natürlich auch lesen. Schließlich muss dies in JS gemeistert werden.
Beispiel 1:
Funktion a () {var user = "little j"; console.log (this.user); // undefined Console.log (dies); // Fenster} a ();Nach dem, was wir oben gesagt haben, weist dies letztendlich auf das Objekt hin, das es nennt. Die Funktion A hier wird vom Fensterobjekt tatsächlich darauf hingewiesen, und der folgende Code kann dies beweisen.
Funktion a () {var user = "little j"; console.log (this.user); // undefined Console.log (dies); } window.a () // FensterGenau wie der obige Code ist Alert tatsächlich eine Eigenschaft des Fensters und wird auch auf das Fenster hingewiesen.
Beispiel 2:
var o = {Benutzer: "Chasing Dreams", fn: function () {console.log (this.user); // Träume jagen}} o.fn ();Dies verweist auf Objekt O, weil Sie dies FN nennen und es über O.FN () ausführen, sodass das natürliche Zeigen Objekt O ist. Ich möchte hier wieder betonen, dass dieser Zeigungsvermögen nicht entschieden werden kann, wenn die Funktion erstellt wird, und sie kann nur dann entschieden werden, wenn sie aufgerufen wird. Wer es nennt, wird darauf hinweisen, dass Sie dies herausfinden müssen.
Tatsächlich sind Beispiel 1 und Beispiel 2 nicht genau genug. Das folgende Beispiel kann die obige Theorie umkippen.
Wenn Sie dies gründlich verstehen möchten, müssen Sie sich die nächsten Beispiele ansehen.
Beispiel 3:
var o = {Benutzer: "Catching Dreams", fn: function () {console.log (this.user); // Dreams}} window.o.fn () fangen;Dieser Code entspricht fast dem obigen Code, aber warum zeigt dieser Fenster? Wenn Sie der obigen Theorie folgen, ist dieser Punkt auf das Objekt, das es nennt. Lassen Sie mich hier etwas anderes sagen. Windows ist ein globales Objekt in JS. Die Variable, die wir erstellen, fügt tatsächlich Attribute zum Fenster hinzu, sodass mit dem Fenster das O -Objekt hier verweist.
Ich werde nicht erklären, warum dieser obige Code nicht auf das Fenster zeigt. Schauen wir uns einen anderen Code an.
var o = {a: 10, b: {a: 12, fn: function () {console.log (this.a); // 12}}} obfn ();Dies wird auch durch Objekt O darauf hingewiesen, aber dies wird nicht ausgeführt, also werden Sie auf jeden Fall sagen, dass das, was ich am Anfang gesagt habe, alles falsch ist? Eigentlich nicht, es ist nur so, dass es am Anfang ungenau war. Als nächstes werde ich einen Satz hinzufügen. Ich glaube, Sie können das Problem, auf das dies hinweist, gründlich verstehen.
======================================================================= >>>>
Fall 1 : Wenn dies in einer Funktion vorhanden ist, es jedoch nicht von einem Objekt auf der vorherigen Ebene aufgerufen wird, weist dies auf das Fenster hin. Was hier erklärt werden muss, ist, dass dies in der strengen Version von JS auf das Fenster verweist, aber wir werden das Problem der strengen Version hier nicht diskutieren. Wenn Sie es wissen möchten, können Sie sich selbst online suchen.
======================================================================= >>>>
Fall 2 : Wenn dies in einer Funktion ist und diese Funktion von einem Objekt auf der vorherigen Ebene aufgerufen wird, weist dies auf das Objekt auf der vorherigen Ebene hin.
======================================================================= >>>>
Fall 3: Wenn dies in einer Funktion ist, enthält diese Funktion mehrere Objekte. Obwohl diese Funktion vom äußersten Objekt aufgerufen wird, weist dies nur auf das Objekt auf der nächsten Ebene hin. Beispiel 3 kann beweisen, dass, wenn Sie es nicht glauben, weiterhin als nächstes einige Beispiele betrachten.
var o = {a: 10, b: {// a: 12, fn: function () {console.log (this.a); // undefined}}} obfn ();Obwohl es in Objekt B kein Attribut A gibt, weist dies auch auf Objekt B hin, da dies nur auf sein vorheriges Objekt hinweist, unabhängig davon, ob es in diesem Objekt etwas hat, das etwas hat.
Es gibt einen weiteren Sonderfall, Beispiel 4:
var o = {a: 10, b: {a: 12, fn: function () {console.log (this.a); // undefined Console.log (dies); // Fenster}}} var j = obfn; j ();Dies weist auf ein Fenster hier hin, ist es nicht ein wenig verwirrt? Tatsächlich liegt es daran, dass Sie keinen Satz verstehen, der ebenfalls entscheidend ist.
Dies weist immer auf das Objekt hin, das es zuletzt nennt, was bedeutet, wer es nennt, wenn es ausgeführt wird. In Beispiel 4 wird die Funktion Fn, obwohl sie durch Objekt B verwiesen wird, bei der Zuweisung von FN Variablen j nicht ausgeführt, sodass es letztendlich auf das Fenster zeigt, was sich von Beispiel 3 unterscheidet. Beispiel 3 führt direkt Fn aus.
Dies ist eigentlich nur das, aber der Zeig, der unter unterschiedlichen Umständen unterschiedlich sein wird. Die obige Zusammenfassung ist ein kleiner Fehler an jedem Ort, und es kann nicht gesagt werden, dass es sich um ein Fehler handelt, aber die Situation wird in verschiedenen Umgebungen unterschiedlich sein, daher kann ich sie nicht klar erklären, sodass Sie sie nur langsam erleben können.
Konstruktorversion Dies:
Funktion fn () {this.user = "small j";} var a = new fn (); console.log (A.User); // klein jDer Grund, warum Object A hier auf den Benutzer in der Funktion FN hinweisen kann, ist, dass das neue Schlüsselwort die Richtung dieses Verhaltens ändern kann und dies auf Objekt a verweisen kann. Warum sage ich, A ist ein Objekt? Da die Verwendung des neuen Schlüsselworts eine Objektinstanz erstellt. Wenn Sie diesen Satz verstehen, können Sie sich unser Beispiel vorstellen. Wir verwenden die Variable A, um eine Instanz von FN zu erstellen (entspricht dem Kopieren eines FN in Objekt A). Zu diesem Zeitpunkt wird es nur erstellt und nicht ausgeführt. Der Aufruf dieser Funktion fn ist Objekt A, daher ist dies natürlich Objekt a. Warum gibt es einen Benutzer in Objekt FN? Da Sie eine FN -Funktion in das Objekt A kopiert haben und das neue Schlüsselwort mit dem Kopieren einer Kopie entspricht.
Zusätzlich zu den oben genannten können wir auch die Richtung von uns selbst ändern.
Aktualisieren Sie ein kleines Problem, wenn diese Begegnungen zurückkehren
Funktion fn () {this.user = 'small j'; zurückkehren {}; } var a = new fn; console.log (A.User); //undefiniertSchau dir einen anderen an
Funktion fn () {this.user = 'small j'; return function () {};} var a = new fn; console.log (A.User); //undefiniertKomm wieder
Funktion fn () {this.user = 'small j'; return 1;} var a = new fn; console.log (A.User); // kleine jfunction fn () {this.user = 'small j'; Rückkehr undefined;} var a = new fn; console.log (A.User); // klein jWenn der Rückgabewert ein Objekt ist, weist dies auf das zurückgegebene Objekt hin. Wenn der Rückgabewert kein Objekt ist, weist dies immer noch auf eine Instanz der Funktion hin.
Funktion fn () {this.user = 'small j'; Rückkehr undefined;} var a = new fn; console.log (a); // fn {Benutzer: "klein J"}Ein weiterer Punkt ist, dass Null zwar auch ein Objekt ist, dies jedoch immer noch auf eine Instanz dieser Funktion hier zeigt, da Null etwas Besonderes ist.
Funktion fn () {this.user = 'small j'; return null;} var a = new fn; console.log (A.User); // klein jErgänzungen von Wissenspunkten:
1. Die Standardeinstellung in der strengen Version ist kein Fenster mehr, sondern undefiniert.
2. Der neue Bediener ändert das Zeigeproblem der Funktion dies. Obwohl wir es oben erklärt haben, haben wir dieses Problem nicht ausführlich besprochen. Es wird selten im Internet erwähnt, daher ist es notwendig, hier darüber zu sprechen.
Funktion fn () {this.num = 1;} var a = new fn (); console.log (a.num); // 1Warum zeigt dieser auf einen? Zunächst erstellt das neue Schlüsselwort ein leeres Objekt, und dann wird eine Funktion angewendet, die automatisch auf dieses leere Objekt verweist. Auf diese Weise wird diese innerhalb der Funktion durch dieses leere Objekt ersetzt.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.