Bevor ich die oben genannten Konzepte erwähne, möchte ich zunächst über die impliziten Parameter von Funktionen in JavaScript sprechen: Argumente
Argumente
Dieses Objekt repräsentiert die Parameter der ausgeführten Funktion und der Funktion, die sie aufruft.
[Funktion.]Argumente[n]
Parameterfunktion: Optionen. Der Name des gerade ausgeführten Funktionsobjekts. n: Option. Der 0-basierte Index des Parameterwerts, der an das Function-Objekt übergeben werden soll.
Beschreibung
Argumente ist ein verstecktes Objekt, das zusätzlich zu den angegebenen Parametern beim Aufruf einer Funktion erstellt wird. Argumente sind ein Objekt, das einem Array, aber keinem Array ähnelt. Es wird als ähnlich einem Array bezeichnet, da es über dieselben Zugriffseigenschaften und Methoden wie ein Array verfügt. Auf den Wert des entsprechenden einzelnen Parameters kann über Argumente zugegriffen werden. n] und hat das Array-Längenattribut Länge. Außerdem speichert das Argumentobjekt die tatsächlich an die Funktion übergebenen Parameter, nicht beschränkt auf die durch die Funktionsdeklaration definierte Parameterliste, und das Argumentobjekt kann nicht explizit erstellt werden. Das Argumentobjekt ist nur am Anfang der Funktion verfügbar. Im folgenden Beispiel werden diese Eigenschaften detailliert beschrieben:
//Verwendung des Argumentobjekts.
Funktion ArgTest(a, b){
var i, s = „Die erwartete ArgTest-Funktion“;
var numargs = arguments.length; // Den Wert des übergebenen Arguments abrufen.
var expargs = ArgTest.length; // Den Wert des erwarteten Parameters abrufen.
if (expargs < 2)
s += expargs + " Argument. ";
anders
s += expargs + " Argumente. ";
if (Anzahl < 2)
s += numargs + " wurde übergeben.";
anders
s += numargs + „wurden übergeben.“;
s += "nn"
for (i =0; i < numargs; i++){ // Parameterinhalt abrufen.
s += " Arg " + i + " = " + arguments[i] + "n";
}
return(s); // Parameterliste zurückgeben.
}
Hier wurde ein Code hinzugefügt, der besagt, dass arguments kein Array (Array-Klasse) ist:
Array.prototype.selfvalue = 1;
alarm(new Array().selfvalue);
Funktion testAguments(){
alarm(arguments.selfvalue);
}
Führen Sie den Code aus und Sie werden feststellen, dass die erste Warnung 1 anzeigt, was bedeutet, dass das Array-Objekt ein Selbstwertattribut mit dem Wert 1 hat. Wenn Sie die Funktion testAguments aufrufen, werden Sie feststellen, dass „undefiniert“ angezeigt wird, was darauf hinweist Es ist kein Attribut von Argumenten. Das heißt, Argumente sind kein Array-Objekt.
Anrufer
Gibt einen Verweis auf die Funktion zurück, die die aktuelle Funktion aufgerufen hat.
Funktionsname.Aufrufer
Das functionName-Objekt ist der Name der ausgeführten Funktion.
Beachten Sie, dass bei Funktionen das Aufruferattribut erst definiert wird, wenn die Funktion ausgeführt wird. Wenn die Funktion von der obersten Ebene aus aufgerufen wird, enthält der Aufrufer null. Wenn das Caller-Attribut in einem String-Kontext verwendet wird, ist das Ergebnis dasselbe wie functionName.toString, d. h. der dekompilierte Text der Funktion wird angezeigt.
Das folgende Beispiel veranschaulicht die Verwendung des Caller-Attributs:
// caller demo {
Funktion callerDemo() {
if (callerDemo.caller) {
var a= callerDemo.caller.toString();
Warnung(a);
} anders {
Alert("Dies ist eine Top-Funktion");
}
}
Funktion handleCaller() {
callerDemo();
}
callee
gibt das ausgeführte Funktionsobjekt zurück, das den Hauptteil des angegebenen Funktionsobjekts darstellt.
[function.]arguments.callee
Der optionale Funktionsparameter ist der Name des gerade ausgeführten Funktionsobjekts.
Beachten Sie, dass
der Anfangswert des aufgerufenen Attributs das ausgeführte Funktionsobjekt ist.
Das aufgerufene Attribut ist ein Mitglied des Argumentobjekts. Es stellt einen Verweis auf das Funktionsobjekt selbst dar, was für die Rekursion anonymer Funktionen oder die Sicherstellung der Kapselung von Funktionen von Vorteil ist. Im folgenden Beispiel wird beispielsweise die Summe natürlicher Funktionen rekursiv berechnet Zahlen von 1 bis n. Diese Eigenschaft ist nur verfügbar, wenn die entsprechende Funktion ausgeführt wird. Es sollte auch beachtet werden, dass callee ein Längenattribut hat, was manchmal zur Überprüfung besser ist. arguments.length ist die tatsächliche Parameterlänge und arguments.callee.length ist die formale Parameterlänge. Daraus können Sie ermitteln, ob die formale Parameterlänge während des Aufrufs mit der tatsächlichen Parameterlänge übereinstimmt.
Beispiel
//callee kann sich selbst drucken
Funktion calleeDemo() {
alarm(arguments.callee);
}
//Wird zur Überprüfung von Parametern verwendet
Funktion calleeLengthDemo(arg1, arg2) {
if (arguments.length==arguments.callee.length) {
window.alert("Überprüfen Sie, ob die formalen und tatsächlichen Parameterlängen korrekt sind!");
zurückkehren;
} anders {
Alert("Tatsächliche Parameterlänge: " +arguments.length);
Alert("Formale Parameterlänge: " +arguments.callee.length);
}
}
//Rekursive Berechnung
var sum = function(n){
wenn (n <= 0)
Rückgabe 1;
anders
return n + arguments.callee(n - 1)
}
Eine allgemeinere rekursive Funktion:
var sum = function(n){
if (1==n) return 1;
sonst return n + sum (n-1);
Beim Aufruf: Alert(sum(100));
Die Funktion enthält einen Verweis auf sum selbst. Der Aufruf von sum innerhalb der Funktion kann nicht gut widerspiegeln, dass er sich selbst aufruft Vergleich. Guter Ansatz.
„apply“ und „call“
dienen dazu, eine Funktion für den Betrieb an ein anderes Objekt zu binden. Der einzige Unterschied zwischen ihnen besteht in der Art der Parameterdefinition:
apply(thisArg,argArray
(thisArg[,arg1,arg2...] ]) ;
Das heißt, dem Zeiger this in allen Funktionen wird der Wert thisArg zugewiesen, wodurch der Zweck erreicht werden kann, die Funktion als Methode eines anderen Objekts auszuführen.
Die Erklärung von Apply
lautet: Wenn argArray kein gültiges Array oder kein Argument ist Objekt, es wird einen TypeError verursachen.
Wenn weder argArray noch thisArg bereitgestellt werden, wird das Global-Objekt als thisArg verwendet.
und es können keine Parameter übergeben werden.
Beschreibung des Aufrufs
Die Aufrufmethode ändert den Objektkontext einer Funktion vom Anfangskontext in das durch thisArg angegebene neue Objekt.
Wenn der Parameter thisArg nicht angegeben ist, wird das globale Objekt als thisArg verwendet.
Verwandte Tipps:
Es gibt einen weiteren Trick beim Anwenden von call und apply. Das heißt, nach der Verwendung von call und apply zum Anwenden einer anderen Funktion (Klasse) wird die aktuelle Funktion () verwendet. Methoden oder Eigenschaften einer anderen Funktion (Klasse) können auch als „Vererbung“ bezeichnet werden. Schauen Sie sich das folgende Beispiel an:
// Demonstration der Vererbung
Funktion base() {
this.member = "dnnsun_Member";
this.method = function() {
window.alert(this.member);
}
}
Funktion verlängern() {
base.call(this);
window.alert(member);
window.alert(this.method);
}
Wie aus dem obigen Beispiel ersichtlich ist, kann „extend“ nach dem Aufruf die Methoden und Eigenschaften von „base“ erben.
Apply wird übrigens im JavaScript-Framework-Prototyp verwendet, um ein Muster zu erstellen
, das eine Klasse definiert. Der Implementierungscode lautet wie folgt:
var Class = {
erstellen: function() {
Rückgabefunktion() {
this.initialize.apply(this, arguments);
}
}
}
Analyse: Aus Code-Sicht enthält dieses Objekt nur eine Methode: Create, die eine Funktion, also eine Klasse, zurückgibt. Dies ist aber auch der Konstruktor der Klasse, der initialize aufruft, und diese Methode ist die Initialisierungsfunktion, die beim Erstellen der Klasse definiert wird. Auf diese Weise,
Sie können das Beispiel für den Klassenerstellungsmodus im Prototyp implementieren
:
var Vehicle=Class.create();
Vehicle.prototype={
initialize:function(type){
this.type=type;
}
showSelf:function(){
alarm("dieses Fahrzeug ist "+ this.type);
}
}
var moto=neues Fahrzeug("Moto");
moto.showSelf();
Ausführlichere Informationen zum Prototyp finden Sie auf der offiziellen Website.
http://www.cnblogs.com/sunwangji/archive/2006/08/21/482341.html