So verwenden Sie das Javascript-Argumentobjekt

Verwendung von JavaScript-Argumentenobjekten: 1. Ermitteln Sie die Anzahl der tatsächlichen Parameter und formalen Parameter. 3. Ändern Sie die Anzahl der tatsächlichen Parameter. 4. Überprüfen Sie, ob die vom Benutzer übergebenen Parameter den Anforderungen entsprechen 5. Funktion Wenn die Anzahl der Parameter unsicher ist, wird sie verwendet, um auf die tatsächlichen Parameterwerte der aufrufenden Funktion zuzugreifen. 6. Durchlaufen oder Zugriff auf die tatsächlichen Parameterwerte.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, JavaScript-Version 1.8.5, Dell G3-Computer. Das

arguments-Objekt stellt die eigentliche Parametersammlung der Funktion dar, die nur innerhalb des Funktionskörpers sichtbar ist und auf die direkt zugegriffen werden kann. Das Längenattribut und das Callee-Attribut des

arguments-Objekts werden am häufigsten verwendet:

• Verwenden Sie das Längenattribut, um die Anzahl der tatsächlichen Parameter der Funktion zu erhalten. Das arguments-Objekt ist nur innerhalb des Funktionskörpers sichtbar, daher kann arguments.length nur innerhalb des Funktionskörpers verwendet werden.

• Verwenden Sie das callee-Attribut, um auf die Funktion zu verweisen, in der sich das aktuelle Argumentobjekt befindet. Verwenden Sie das Attribut callee, um die Funktion selbst innerhalb des Funktionskörpers aufzurufen. In anonymen Funktionen ist das callee-Attribut nützlich. Beispielsweise können damit rekursive Aufrufe entworfen werden.

Beispiel 1: Anzahl der tatsächlichen Parameter und formalen Parameter ermitteln

Verwenden Sie die Eigenschaft arguments.length, um die Anzahl der tatsächlichen Parameter einer Funktion abzurufen. Die Anzahl der formalen Parameter der Funktion kann mithilfe der Längeneigenschaft des Funktionsobjekts ermittelt werden. Diese Eigenschaft ist eine schreibgeschützte Eigenschaft 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 Parameter und tatsächlichen Parameter einer Funktion konsistent sind. Wenn sie inkonsistent sind, wird eine Ausnahme ausgelöst.

function checkArg(a) {  //检测函数实参与形参是否一致
    if (a.length != a.callee.length)  //如果实参与形参个数不同，则抛出错误
    throw new Error("实参和形参不一致");
}
function f(a, b) {  //求两个数的平均值
    checkArg(arguments);   //根据arguments来检测函数实参和形参是否一致
    return ((a * 1 ? a : 0) + (b * 1 ? b : 0)) / 2;  //返回平均值
}
console.log(f(6));  //抛出异常。调用函数f，传入一个参数

Beispiel 2: Ändern Sie den Wert des tatsächlichen Parameters innerhalb der Funktion

Im folgenden Beispiel verwenden Sie eine for-Schleife, um das Argumentobjekt zu durchlaufen, und übergeben Sie dann den Wert der Schleifenvariablen an Argumente, um den tatsächlichen Parameter zu ändern Parameterwert.

function f() {
    for (var i = 0; i < arguments.length； i++) {  //遍历arguments对象
        arguments[i] = i;  //修改每个实参的值
        console.log(arguments[i]);  //提示修改的实参值
    }
}
f(3, 3, 6);  //返回提示0、1、2，而不是3、3、6

Beispiel 3: Ändern der Anzahl der tatsächlichen Parameter der Funktion

Durch Ändern des Längenattributwerts können Sie auch die Anzahl der tatsächlichen Parameter der Funktion ändern. Wenn der Wert des Längenattributs zunimmt, ist der hinzugefügte tatsächliche Parameterwert undefiniert. Wenn der Wert des Längenattributs abnimmt, wird der tatsächliche Parameterwert nach dem Längenwert verworfen.

function f() {
    arguments.length = 2;  //修改arguments属性对象的length属性值
    for (var i = 0; i < arguments.length; i ++) {
        console.log(arguments[i]);
    }
}
f(3, 3, 6);  //返回提示3、3

Beispiel 4: Überprüfen Sie, ob die vom Benutzer übergebenen Parameter die Anforderungen erfüllen

Im folgenden Beispiel verwenden Sie arguments.callee, um die anonyme Funktion abzurufen, und ermitteln Sie dann die Anzahl der Funktionsparameter über das Längenattribut der Funktion Vergleichen Sie schließlich die Anzahl der tatsächlichen Parameter und die Anzahl der formalen Parameter, um zu überprüfen, ob die vom Benutzer übergebenen Parameter den Anforderungen entsprechen.

function f(x,y,z) {
    var a = arguments.length();  //获取函数实参的个数
    var b = arguments.callee.length;  //获取函数形参的个数
    if (a != b_ {  //如果实参和形参个数不相等，则提示错误信息
        throw new Error("传递的参数不匹配");
    }else {  //如果实参和形参个数相同，则返回它们的和
        return x + y + z; 
    }
}
console.log(f(3,4,5));  //返回值12

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

Anwendung des Argumentobjekts

In der tatsächlichen Entwicklung ist das Argumentobjekt sehr nützlich. Die flexible Verwendung des Argumentobjekts kann die Flexibilität bei der Verwendung von Funktionen verbessern und die Anpassungsfähigkeit und Fehlerkorrekturfähigkeiten von Funktionen in der abstrakten Programmierung verbessern. Im Folgenden werden einige typische Beispiele kombiniert, um die Anwendung von Argumenten zu demonstrieren.

1) Die Verwendung des Argumentobjekts kann die Flexibilität der Funktionsanwendung erhöhen. Wenn beispielsweise die Anzahl der Parameter der Funktion unsicher ist oder die Anzahl der Parameter der Funktion groß ist und Sie nicht jeden formalen Parameter einzeln definieren möchten, können Sie die Definition von Parametern weglassen und das Argumentobjekt direkt verwenden im Funktionskörper, um auf die tatsächlichen Parameterwerte der aufrufenden Funktion zuzugreifen.

Beispiel 1

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.

function avg() {  //求平均值
    var num = 0, 1 = 0;  //声明并初始化临时变量
    for (var i = 0; i < arguments.length; i ++) {  //遍历所有实参
        if (typeof arguments[i] != "number")  //如果参数不是数值
            continue;  //则忽略该参数值
        num += arguments[i];  //计算参数的数值之和
            1 ++;  //计算参与和运算的参数个数
    }    
    num /= 1;  //求平均值
    return num;  //返回平均值
}
console.log(avg(1,2,3,4));  //返回2.5
console.log(avg(1,2,"3",4));  //返回2.3333333333333335

Beispiel 2

Beim Seitendesign ist es oft notwendig, Formulareingabewerte zu überprüfen. Das folgende Beispiel prüft, ob der im Textfeld eingegebene Wert eine gültige E-Mail-Adresse ist.

function isEmail() {
    if (arguments.length > 1) throw new Error("只能够传递一个参数");  //检测参数个数
    var regexp = /^\w+((-\w+) | (\.\w+)) *\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)8\.[A-Za-z0-9]+$/;  //定义正则表达式
    if (arguments[0].search(regexp) != -1)  //匹配实参的值
        return true;  //如果匹配则返回true
    else 
        return false;  //如果不匹配则返回false
}
var email = "1798017447@qq.com";  //声明并初始化邮箱地址字符串
console.log(isEmail(email));  //返回true

2) arguments-Objekt ist ein Pseudoklassen-Array, kein Array, und die Werte tatsächlicher Parameter können über die Längeneigenschaft und die Klammersyntax durchlaufen oder darauf zugegriffen werden. Durch dynamisches Aufrufen von Methoden können Sie jedoch auch Array-Methoden wie Push, Pop, Slice usw. verwenden.

Beispiel 3

Verwenden Sie Argumente, um eine Überlastung zu simulieren. Implementierungsmethode: Verwenden Sie den Attributwert arguments.length, um die Anzahl und Art der tatsächlichen Parameter zu bestimmen und zu entscheiden, unterschiedliche Codes auszuführen.

function sayHello() {
    switch(arguments.length) {
        case 0 :
            return "Hello";
        case 1 :
            return "Hello, " + arguments[0];
        case 2 :
            return (arguments[1] == "cn" ? "你好, " : "Hello, ") + arguments[0];
    };
}
console.log(sayHello());  //"Hello"
console.log(sayHello("Alex"));  //"Hello,Alex"
console.log(sayHello("Alex", "vn"));  //"你好,Alex"

Beispiel 4

Das folgende Beispiel verwendet die dynamische Aufrufmethode, um das Argumentobjekt die Array-Methode Slice() aufrufen zu lassen, die das Funktionsparameterobjekt in ein Array konvertieren kann.

function f() {
    return [].slice.apply(arguments);
}
console.log(f(1,2,3,4,5,6));  //返回[1,2,3,4,5,6]

【Empfohlenes Lernen: Javascript-Tutorial für Fortgeschrittene】

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das Javascript-Argumentobjekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!