Detaillierte Erklärung zur Verwendung des Arguments-Objekts in JavaScript

In der tatsächlichen Entwicklung ist das Arguments-Objekt sehr nützlich. Die flexible Verwendung von Argumentobjekten kann die Flexibilität bei der Verwendung von Funktionen verbessern und die Anpassungsfähigkeit und Fehlerkorrekturfunktionen von Funktionen in der abstrakten Programmierung verbessern.

Zusammenfassung des Zwecks des Arguments-Objekts in JavaScript.

Vorwort

Ich glaube, viele von uns haben im Prozess der Codeentwicklung ein spezielles Objekt verwendet – das Arguments-Objekt.

In der tatsächlichen Entwicklung ist das Arguments-Objekt sehr nützlich. Die flexible Verwendung von Argumentobjekten kann die Flexibilität bei der Verwendung von Funktionen verbessern und die Anpassungsfähigkeit und Fehlerkorrekturfunktionen von Funktionen in der abstrakten Programmierung verbessern.

Wie sollte also das Arguments-Objekt verwendet werden? Lassen Sie uns heute zusammenfassen.

Grundlegende Konzepte von Argumenten

Argumente sind arrayähnliche Objekte, die den an die Funktion übergebenen Argumenten entsprechen.

Arguments ist ein Objekt, das einem Array ähnelt, aber kein Array ist. Es ähnelt einem Array, da es dieselben Zugriffseigenschaften und Methoden wie ein Array hat. Der Wert des entsprechenden einzelnen Parameters kann über arguments[n] abgerufen werden und es hat ein Array-Längenattribut. Darüber hinaus speichert das Arguments-Objekt die Parameter, die tatsächlich an die Funktion übergeben werden, und ist nicht auf die in der Funktionsdeklaration definierte Parameterliste beschränkt. Das Arguments-Objekt kann nicht explizit erstellt werden.

Hier ist ein einfaches Beispiel für die Verwendung von Argumenten:

Funktion func1(a, b, c) {
    Konsole.log(Argumente[0]);
    console.log(Argumente[1]);
    console.log(Argumente[2]);
}

Funktion1(1, 2, 3);
// 1
// 2
// 3

Wir können den übergebenen Parametersatz direkt über arguments innerhalb der Funktion abrufen und dann den Parameterwert der entsprechenden Position in Form eines Arrays abrufen.

Die Rolle der Argumente

Welche Verwendung finden Argumente als spezielles Objekt in JavaScript und wie werden sie verwendet?

Ermitteln Sie die Anzahl der tatsächlichen und formalen Parameter

Verwenden Sie die Eigenschaft arguments.length, um die Anzahl der tatsächlichen Parameter einer Funktion zu erhalten. Mit der Längeneigenschaft des Funktionsobjekts kann die Anzahl der formalen Parameter der Funktion ermittelt werden. Diese Eigenschaft ist schreibgeschützt und kann sowohl innerhalb als auch außerhalb des Funktionskörpers verwendet werden.

Das folgende Beispiel entwirft eine checkArg()-Funktion, um zu prüfen, ob die formalen und tatsächlichen Parameter einer Funktion konsistent sind, und um eine Ausnahme auszulösen, wenn dies nicht der Fall ist.

Funktion checkArg(a) {
    //Überprüfen Sie, ob der tatsächliche Parameter und der formale Parameter der Funktion konsistent sind, wenn (a.length != a.callee.length)
        //Wenn die Anzahl der tatsächlichen Parameter von der Anzahl der formalen Parameter abweicht, wird ein Fehler ausgelöst. throw new Error("tatsächliche Parameter und formale Parameter sind inkonsistent");
}

Funktion f(a, b) {
    //Berechne den Durchschnitt zweier Zahlen checkArg(Argumente); //Verwende Argumente, um zu prüfen, ob die tatsächlichen und formalen Parameter der Funktion übereinstimmen return ((a * 1 ? a : 0) + (b * 1 ? b : 0)) / 2; //Gib den Durchschnittswert zurück }
console.log(f(6)); //Löst eine Ausnahme aus. Rufen Sie die Funktion f auf und übergeben Sie einen Parameter

Ändern Sie den tatsächlichen Parameterwert

Im folgenden Beispiel wird eine For-Schleife verwendet, um über das Argumentobjekt zu iterieren. Anschließend wird der Wert der Schleifenvariable an Argumente übergeben, um die Änderung des tatsächlichen Parameterwerts zu erleichtern.

Funktion f() {
    for (let i = 0; i < arguments.length; i++) { //Das Argumentobjekt durchlaufen arguments[i] = i; //Den Wert jedes aktuellen Parameters ändern console.log(arguments[i]); //Den geänderten aktuellen Parameterwert abfragen}
}

f(3, 3, 6); //Gibt die Eingabeaufforderungen 0, 1, 2 statt 3, 3, 6 zurück

Ändern der Anzahl der Argumente

Durch Ändern des Längeneigenschaftswerts können Sie auch die Anzahl der tatsächlichen Parameter der Funktion ändern. Wenn der Längeneigenschaftswert zunimmt, ist der erhöhte tatsächliche Parameterwert undefiniert; wenn der Längeneigenschaftswert abnimmt, wird der tatsächliche Parameterwert nach dem Längenwert verworfen.

Funktion f() {
    arguments.length = 2; //Ändere den Längeneigenschaftswert des Argumente-Eigenschaftsobjekts for (let i = 0; i < arguments.length; i++) {
        Konsole.log(Argumente[i]);
    }
}

f(3, 3, 6); //Gibt Eingabeaufforderung 3, 3 zurück

Überprüfen der Parametergültigkeit

Im folgenden Beispiel wird arguments.callee verwendet, um eine anonyme Funktion abzurufen. Anschließend wird die Anzahl der Funktionsparameter über die Längeneigenschaft der Funktion abgerufen. Schließlich wird die Anzahl der tatsächlichen Parameter mit der Anzahl der formalen Parameter verglichen, um zu prüfen, ob die vom Benutzer übergebenen Parameter den Anforderungen entsprechen.

Funktion f(x,y,z) {
    let a = arguments.length; //Anzahl der tatsächlichen Parameter der Funktion abrufen let b = arguments.callee.length; //Anzahl der formalen Parameter der Funktion abrufen if (a != b){ //Wenn die Anzahl der tatsächlichen Parameter und der formalen Parameter nicht gleich ist, wird eine Fehlermeldung angezeigt throw new Error("Die übergebenen Parameter stimmen nicht überein");
    }else { //Wenn die Anzahl der tatsächlichen Parameter und der formalen Parameter gleich ist, gib deren Summe zurück return x + y + z;
    }
}

console.log(f(3,4,5)); //Rückgabewert 12

arguments.callee entspricht dem Funktionsnamen. Im obigen Beispiel ist arguments.callee gleich f.

Wenn die Anzahl der Funktionsparameter ungewiss ist, wird sie verwendet, um auf den tatsächlichen Parameterwert der aufrufenden Funktion zuzugreifen

Wenn die Anzahl der Funktionsparameter ungewiss ist oder die Funktion über eine große Anzahl von Parametern verfügt und Sie nicht jeden formalen Parameter einzeln definieren möchten, können Sie die Definition der Parameter weglassen und direkt das Arguments-Objekt im Funktionskörper verwenden, um auf die tatsächlichen Parameterwerte der aufrufenden Funktion zuzugreifen.

Das folgende Beispiel definiert eine Durchschnittsfunktion, die das Argumentobjekt verwendet, um den Durchschnitt der Parameter zu berechnen. Beim Aufruf einer Funktion können Sie beliebig viele Parameter übergeben.

Funktion Durchschnitt () {
    //Den Durchschnittswert ermitteln let num = 0;
    let length = 0; // Temporäre Variablen deklarieren und initialisieren für (let i = 0; i < arguments.length; i++) {
        //Alle tatsächlichen Parameter durchlaufen if (typeof arguments[i] != "number") {
            //Wenn der Parameter kein numerischer Wert ist, weiter; //dann den Parameterwert ignorieren}
        num += arguments[i]; //Berechne die Summe der numerischen Werte der Parameter length++; //Berechne die Anzahl der an der Summenoperation beteiligten Parameter}

    return num / length; //Gibt den Durchschnittswert zurück}

console.log(avg(1, 2, 3, 4)); //Gibt 2,5 zurück
console.log(avg(1, 2, "3", 4)); //Gibt 2,33333333333333335 zurück

Den Wert des tatsächlichen Parameters durchlaufen oder darauf zugreifen

Das Argumentobjekt ist ein Pseudoarray, kein Array. Sie können den Wert des tatsächlichen Parameters über das Längenattribut und die Klammernsyntax durchlaufen oder darauf zugreifen. Sie können jedoch auch Array-Methoden wie Push, Pop, Slice usw. über dynamische Aufrufmethoden verwenden.

Im folgenden Beispiel wird die dynamische Aufrufmethode verwendet, damit das Argumentobjekt die Array-Methode slice() aufruft, um das Funktionsparameterobjekt in ein Array zu konvertieren.

Funktion f() {
    return [].slice.apply(Argumente);
    // Sie können auch den folgenden Ausdruck verwenden // return Array.from(arguments);
    // returniere [...Argumente];
}
console.log(f(1, 2, 3, 4, 5, 6)); //Gibt [1,2,3,4,5,6] zurück

Zusammenfassen

Das Obige ist eine Zusammenfassung der praktischen Verwendung des Arguments-Objekts. Ich hoffe, wir alle können Arguments flexibel verwenden und poetischen Code schreiben!

Dies ist das Ende dieses Artikels über die Verwendung des Arguments-Objekts in JavaScript. Weitere Informationen zur Verwendung des Arguments-Objekts in JavaScript finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!