Jede JavaScript -Funktion kann auf eine spezielle Variable - Argumente innerhalb ihres Bereichs zugreifen. Diese Variable enthält eine Liste aller an die Funktion übergebenen Parameter.
Das Argumenteobjekt ist kein Array. Obwohl es syntaktisch den gleichen Ort wie ein Array hat, hat es beispielsweise die Länge Eigenschaft. Aber es wird nicht von Array.Prototyp geerbt, tatsächlich ist es ein Objekt.
Daher können wir einige Array -Methoden für Argumente wie Push, Pop oder Slice usw. nicht direkt anwenden. Um diese Methoden zu verwenden, müssen wir es in ein echtes Array umwandeln.
In ein Array konvertieren
Der folgende Code gibt ein Array zurück, das alle Elemente des Argumenteobjekts enthält.
Array.Prototype.slice.call (Argumente);
Da die Conversion -Geschwindigkeit sehr langsam ist, wird dies in Programmen mit strengen Leistungsanforderungen nicht empfohlen.
Parameter übergeben
Hier finden Sie eine empfohlene Methode, um das Argumenteobjekt von einer Funktion an eine andere zu übergeben.
Die Codekopie lautet wie folgt:
Funktion foo () {
bar.Apply (NULL, Argumente);
}
Funktionsleiste (a, b, c) {
// Mach hier Sachen
}
Es gibt eine andere clevere Methode, bei der es darum geht, schnell eine ungehinderte äußere Methode mit dem Aufruf zu erstellen und gleichzeitig anzuwenden.
Die Codekopie lautet wie folgt:
Funktion foo () {}
Foo.prototype.method = function (a, b, c) {
console.log (this, a, b, c);
};
// Erstellen Sie eine ungebundene Version von "Methode"
// Es nimmt die Parameter: Dies, Arg1, arg2 ... argn
Foo.method = function () {
// Ergebnis: foo.prototype.method.call (this, arg1, arg2 ... argn)
Function.call.apply (foo.Prototype.Method, Argumente);
};
Die Beziehung zwischen Funktionsparametern und Argumenten Attribute
Das Argumenteobjekt erstellt Getter- und Setter -Methoden sowohl für seine eigenen Eigenschaften als auch für die Funktionsparameter.
Das Ändern der formalen Parameter der Funktion wirkt sich daher auf die Eigenschaftswerte des entsprechenden Argumenteobjekts aus und umgekehrt.
Die Codekopie lautet wie folgt:
Funktion foo (a, b, c) {
Argumente [0] = 2;
A; // 2
B = 4;
Argumente [1]; // 4
var d = c;
D = 9;
C; // 3
}
Foo (1, 2, 3);
Leistungsprobleme
Argumente werden in nur zwei Fällen nicht erstellt, einer wird als lokale Variable innerhalb der Funktion deklariert und der andere als formaler Parameter der Funktion verwendet. In anderen Fällen wird das Argumenteobjekt immer erstellt.
Da Getter- und Setter -Methoden immer mit der Erstellung von Argumentenobjekten erstellt werden, hat die Verwendung von Argumenten nur geringe Auswirkungen auf die Leistung selbst.
Es gibt jedoch eine Situation, die die Leistung von JavaScript ernsthaft beeinflusst, nämlich Argumente. Callee.
Die Codekopie lautet wie folgt:
Funktion foo () {
Argumente.Callee; // etwas mit diesem Funktionsobjekt machen
argumente.callee.caller; // und das aufrufende Funktionsobjekt
}
Funktion bigloop () {
für (var i = 0; i <100000; i ++) {
foo (); // würde normalerweise eingebaut ...
}
}
Im obigen Code ist die FOO -Funktion keine einfache Inline -Erweiterung mehr, da sie sich und ihren Anrufer kennen muss. Dies setzt nicht nur die Leistungsverbesserungen aus, die durch Inline -Erweiterungen mitgebracht werden, sondern untergräbt auch die Einkapselung der Funktion, da sich die Funktion selbst möglicherweise auf einen bestimmten aufrufenden Hintergrund verlassen muss.
Daher wird empfohlen, keine Argumente zu verwenden. Callee.
Das obige dreht sich alles um das JavaScript -Argumenteobjekt. Weißt du es gründlich? Einfach gesagt
Argumente beziehen sich auf das Parameterobjekt der Funktion (bezieht sich auf die tatsächlichen übergebenen Parameter)
Argumente.Length bezieht sich auf die Länge des Parameterobjekts der Funktion.
Argumente [i] bezieht sich auf den Wert des I-ten Parameters (der erste ist 0)