Javascript-Studiennotizen – Funktionen (4): Argumente object_basic Wissen

Jede Javascript-Funktion kann auf eine spezielle Variable in ihrem eigenen Bereich zugreifen – Argumente. Diese Variable enthält eine Liste aller an die Funktion übergebenen Argumente.
Das Argumentobjekt ist kein Array. Obwohl es syntaktisch die gleichen Merkmale wie ein Array aufweist, verfügt es beispielsweise über eine Längeneigenschaft. Aber es erbt nicht von Array.prototype, sondern ist tatsächlich ein Objekt.
Daher können wir einige Array-Methoden wie Push, Pop oder Slice nicht direkt für Argumente verwenden. Um diese Methoden verwenden zu können, müssen wir sie in ein echtes Array konvertieren.

In Array konvertieren

Der folgende Code gibt ein Array zurück, das alle Elemente des Argumentobjekts enthält.

Array.prototype.slice.call(arguments);
Da die Konvertierung sehr langsam ist, ist dies bei leistungskritischen Programmen nicht zu empfehlen.

Parameter übergeben

Das Folgende ist eine empfohlene Methode, um das Argumentobjekt von einer Funktion an eine andere zu übergeben.

Code kopieren Der Code lautet wie folgt:

Funktion foo() {
bar.apply(null, arguments);
}
Funktionsleiste(a, b, c) {
// mach Sachen hier
}

Eine weitere clevere Methode besteht darin, call und apply gleichzeitig zu verwenden, um schnell eine ungebundene äußere Methode zu erstellen.

Code kopieren Der Code lautet wie folgt:

Funktion Foo() {}
Foo.prototype.method = function(a, b, c) {
console.log(this, a, b, c);
};
// Erstelle eine ungebundene Version von „method“
// Es nimmt die Parameter an: this, arg1, arg2...argN
Foo.method = function() {
// Ergebnis: Foo.prototype.method.call(this, arg1, arg2... argN)
Function.call.apply(Foo.prototype.method, arguments);
};

Die Beziehung zwischen Funktionsparametern und Argumentattributen

Das Objekt

arguments erstellt Getter- und Setter-Methoden sowohl für seine eigenen Eigenschaften als auch für die formalen Parameter seiner Funktionen.
Daher wirkt sich die Änderung der formalen Parameter einer Funktion auf die Eigenschaftswerte des entsprechenden Argumentobjekts aus und umgekehrt.

Code kopieren Der Code 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 nur in zwei Situationen erstellt: eines wird als lokale Variable innerhalb der Funktion deklariert und das andere wird als formaler Parameter der Funktion verwendet. Andernfalls wird immer das Argumentobjekt erstellt.
Da Getter- und Setter-Methoden immer mit dem Argumentobjekt erstellt werden, hat die Verwendung von Argumenten selbst nur geringe Auswirkungen auf die Leistung.
Es gibt jedoch eine Situation, die die Leistung von Javascript ernsthaft beeinträchtigt, und zwar die Verwendung von arguments.callee.

Code kopieren Der Code lautet wie folgt:

Funktion foo() {
arguments.callee; // etwas mit diesem Funktionsobjekt machen
arguments.callee.caller; // und das aufrufende Funktionsobjekt
}
Funktion bigLoop() {
for(var i = 0; i < 100000; i ) {
foo(); // Würde normalerweise inline sein...
}
}

Im obigen Code ist die foo-Funktion keine einfache Inline-Erweiterung mehr, da sie sowohl sich selbst als auch ihren Aufrufer kennen muss. Dies macht nicht nur den Leistungsgewinn durch die Inline-Erweiterung zunichte, sondern zerstört auch die Kapselung der Funktion, da die Funktion selbst möglicherweise von einem bestimmten Aufrufkontext abhängig sein muss.
Daher wird empfohlen, dass Sie versuchen, arguments.callee nicht zu verwenden.

Das Obige dreht sich alles um das Javascript-Argument-Objekt. Versteht ihr es gründlich?

Argumente beziehen sich auf das Parameterobjekt der Funktion (bezogen auf die tatsächlich übergebenen Parameter)
arguments.length bezieht sich auf die Länge des Parameterobjekts der Funktion
arguments[i] bezieht sich auf den Wert des i-ten Parameters (der erste ist 0)