JavaScript-Serie für Fortgeschrittene – Argumentobjekt

• In Array konvertieren

• Parameter übergeben

• Automatisch aktualisieren

• Leistungswahrheit

Jede Funktion in JavaScript kann auf spezielle Variablenargumente zugreifen. Diese Variable verwaltet die Liste aller an diese Funktion übergebenen Parameter.

Argument-Variable ist kein Array (Array). Obwohl es syntaktisch die Array-bezogene Eigenschaft Länge hat, erbt es nicht von Array.prototype und ist tatsächlich ein Objekt.

(Hinweis: Da Argumente als Variable innerhalb der Funktion definiert wurden. Daher führt die Definition von Argumenten über das Schlüsselwort var oder die Deklaration von Argumenten als formale Parameter dazu, dass keine nativen Argumente erstellt werden.)

Daher können Standard-Array-Methoden wie Push, Pop oder Slice nicht für die Variable arguments verwendet werden. Obwohl es möglich ist, eine for-Schleife zum Durchlaufen zu verwenden, ist es zur besseren Nutzung der Array-Methode am besten, sie in ein echtes Array umzuwandeln.

In Array konvertieren

Der folgende Code erstellt ein neues Array, das alle Elemente im Argumentobjekt enthält.

Array.prototype.slice.call(arguments);

Diese Konvertierung ist langsam und wird in Code mit schlechter Leistung nicht empfohlen.

Übergabe von Parametern

Das Folgende ist die empfohlene Vorgehensweise für die Übergabe von Parametern von einer Funktion an eine andere.

function foo() {
    bar.apply(null, arguments);
}
function bar(a, b, c) {
    // 干活
}

Ein weiterer Trick besteht darin, „call“ und „apply“ zusammen zu verwenden und so einen schnellen Unbinding-Wrapper zu erstellen.

function Foo() {}

Foo.prototype.method = function(a, b, c) {
    console.log(this, a, b, c);
};

// 创建一个解绑定的 "method"
// 输入参数为: this, arg1, arg2...argN
Foo.method = function() {

    // 结果: Foo.prototype.method.call(this, arg1, arg2... argN)
    Function.call.apply(Foo.prototype.method, arguments);
};

Anmerkung des Übersetzers: Die obige Foo.method-Funktion hat den gleichen Effekt wie der folgende Code:

Foo.method = function() {
    var args = Array.prototype.slice.call(arguments);
    Foo.prototype.method.apply(args[0], args.slice(1));
}

Aktualisiert automatisch das

arguments-Objekt in seiner Eigenschaft und formale Funktionsparameter erstellen Getter- und Setter-Methoden.

Daher wirkt sich eine Änderung des Werts des formalen Parameters auf den Wert des Argumentobjekts aus und umgekehrt.

function foo(a, b, c) {
    arguments[0] = 2;
    a; // 2                                                           

    b = 4;
    arguments[1]; // 4

    var d = c;
    d = 9;
    c; // 3
}
foo(1, 2, 3)

Performance Truth

Das Argumentobjekt wird immer erstellt, unabhängig davon, ob es verwendet wird, mit Ausnahme von zwei Sonderfällen – als lokale Variable und als formaler Parameter deklariert. Die Getter- und Setter-Methoden von

Argumenten werden immer erstellt, daher hat die Verwendung von Argumenten keinen Einfluss auf die Leistung. Es sei denn, Sie müssen mehrmals auf die Eigenschaften des Argumentobjekts zugreifen.

Anmerkung des Übersetzers: Die Beschreibung der Argumente im strikten Modus in MDC ist für unser Verständnis hilfreich. Bitte schauen Sie sich den folgenden Code an:

// 阐述在 ES5 的严格模式下 `arguments` 的特性
function f(a) {
  "use strict";
  a = 42;
  return [a, arguments[0]];
}
var pair = f(17);
console.assert(pair[0] === 42);
console.assert(pair[1] === 17);

Eine Situation wird es jedoch tatsächlich geben wirkt sich erheblich auf die Leistung moderner JavaScript-Engines aus. Dies verwendet arguments.callee.

function foo() {
    arguments.callee; // do something with this function object
    arguments.callee.caller; // and the calling function object
}

function bigLoop() {
    for(var i = 0; i < 100000; i++) {
        foo(); // Would normally be inlined...
    }
}

Im obigen Code ist foo nicht länger eine einfache Inline-Funktion (Anmerkung des Übersetzers: Dies bezieht sich auf den Parser, der Inlining-Verarbeitung durchführen kann), da er sich selbst und seinen Aufrufer kennen muss. Dies macht nicht nur den Leistungsgewinn durch Inlining-Funktionen zunichte, sondern bricht auch die Kapselung, sodass Funktionen jetzt möglicherweise von einem bestimmten Kontext abhängen.

Daher wird dringend empfohlen, arguments.callee und seine Eigenschaften nicht zu verwenden.

Das Obige ist der Inhalt der JavaScript-Erweitert-Serie – Argumente-Objekt. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!