In Javascritp ist dies nicht unbedingt der einzige Kontext der Objektmethode, und dies wird auch in globalen Funktionsaufrufen und mehreren anderen verschiedenen Kontexten bezeichnet.
Es kann ein globales Objekt, ein aktuelles Objekt oder ein beliebiges Objekt sein, abhängig davon, wie die Funktion aufgerufen wird. Es gibt verschiedene Möglichkeiten, Funktionen in JavaScript aufzurufen: als Objektmethodenaufrufe, wie Funktionsaufrufe, als Konstruktoraufrufe und Verwendung von Anwenden oder Aufrufen.
1. Rufen Sie als Objektmethode auf
In JavaScript sind Funktionen auch Objekte, sodass Funktionen als Attribute eines Objekts verwendet werden können.
Die Codekopie lautet wie folgt:
var point = {
x: 0,
y: 0,
MoveTo: Funktion (x, y) {
this.x = this.x + x;
this.y = this.y + y;
}
};
point.moveto (1, 1) // Dies bindet an das aktuelle Objekt, dh Point -Objekt
2. als Funktionsaufruf
Die Funktion kann auch direkt aufgerufen werden und ist an das globale Objekt gebunden. Im Browser ist Fenster das globale Objekt. Zum Beispiel das folgende Beispiel: Wenn eine Funktion aufgerufen wird, ist dies an das globale Objekt gebunden, und die Zuordnungsanweisung wird als nächstes ausgeführt, was gleichwertig einer globalen Variablen entspricht, was offensichtlich nicht das ist, was der Anrufer will.
Die Codekopie lautet wie folgt:
Funktion makenosense (x) {
this.x = x;
}
MakenoSense (5);
x; // x ist zu einer globalen Variablen mit einem Wert von 5 geworden
Für interne Funktionen, dh deklarierte Funktionen im Körper einer anderen Funktion, wird diese Art der Bindung an ein globales Objekt ein weiteres Problem erzeugen. Wir werden das zuvor erwähnte Punktobjekt als Beispiel verwenden. Das Ergebnis kann unerwartet sein.
Die Codekopie lautet wie folgt:
var point = {
x: 0,
y: 0,
MoveTo: Funktion (x, y) {
// interne Funktionen
var movex = function (x) {
This.x = x; // wo ist das gebunden?
};
// interne Funktionen
var movey = function (y) {
this.y = y; // wo ist das gebunden?
};
Movex (x);
Movey (y);
}
};
point.moveto (1, 1);
point.x; // ==> 0
point.y; // ==> 0
x; // ==> 1
y; // ==> 1
Dies ist ein Entwurfsfehler von JavaScript.
Die Codekopie lautet wie folgt:
var point = {
x: 0,
y: 0,
MoveTo: Funktion (x, y) {
var das = dies;
// interne Funktionen
var movex = function (x) {
that.x = x;
};
// interne Funktionen
var movey = function (y) {
that.y = y;
}
Movex (x);
Movey (y);
}
};
point.moveto (1, 1);
point.x; // ==> 1
point.y; // ==> 1
Als Konstruktor genannt
JavaScript unterstützt die objektorientierte Programmierung. Entsprechend sind die Konstruktoren in JavaScript auch ganz besondere. Als eine weitere herkömmliche Regel beginnt der Konstruktor mit Großbuchstaben, um den Anrufer daran zu erinnern, auf die richtige Art und Weise anzurufen. Wenn der Anruf korrekt ist, ist dies an das neu erstellte Objekt gebunden.
Die Codekopie lautet wie folgt:
Funktionspunkt (x, y) {
this.x = x;
this.y = y;
}
Mithilfe von Antrag oder Anruf aufgerufen
Lassen Sie uns wiederholen, dass in JavaScript -Funktionen auch Objekte, Objekte Methoden und Anwenden und Aufruf Methoden von Funktionsobjekten sind. Diese beiden Methoden sind extrem leistungsfähig und ermöglichen das Umschalten des Kontextes der Funktionsausführung, d. H. Das daran gebundene Objekt. Diese Methode wird in vielen JavaScript -Techniken und Klassenbibliotheken verwendet. Schauen wir uns ein bestimmtes Beispiel an:
Die Codekopie lautet wie folgt:
Funktionspunkt (x, y) {
this.x = x;
this.y = y;
this.moveto = function (x, y) {
this.x = x;
this.y = y;
}
}
var p1 = neuer Punkt (0, 0);
var p2 = {x: 0, y: 0};
P1.Moveto (1, 1);
p1.moveto.apply (p2, [10, 10]);
Im obigen Beispiel verwenden wir den Konstruktor, um ein Objekt P1 zu erzeugen, das auch eine Moveto -Methode hat. Ein anderer Methodenaufruf hat ebenfalls die gleiche Funktion. Der Unterschied besteht darin, dass der letzte Parameter nicht als Array in einheitlich übergeben wird, sondern ein separates übergeben wird.
Die Codekopie lautet wie folgt:
Funktion foo () {
//1.Dieis referenzierter Konstruktor ist ein von argument.callee verwiesenes Objekt
// Anweisungen sind Konstruktoren, die über den neuen Bediener ausgeführt werden
if (this.constructor == Argumente.Callee) {
alert ('Objekt erstellt');
}
//2. Dieses Fenster ist dann ein globaler Anruf
if (this == Fenster) {
alarm ('normaler Anruf');
}
sonst {// 3.
alarm ('CALL BY'+ this.constructor);
}
}
Foo (); // globaler Funktionsaufruf
Foo.call (New Object ()); // Aufrufen als Mitgliedsmethode eines Objektobjekts
New Foo (); // vom neuen Bediener gerufen, um die Objektkonstruktion auszuführen