Comment utiliser l'objet arguments javascript

Utilisation de l'objet arguments JavaScript : 1. Obtenez le nombre de paramètres réels et de paramètres formels ; 2. Modifiez les valeurs réelles des paramètres ; 3. Modifiez le nombre de paramètres réels 4. Vérifiez si les paramètres transmis par l'utilisateur répondent aux exigences ; ; 5. Fonction Lorsque le nombre de paramètres est incertain, il est utilisé pour accéder aux valeurs réelles des paramètres de la fonction appelante ; 6. Parcourez ou accédez aux valeurs réelles des paramètres ;

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3. L'objet

arguments représente la collection de paramètres réelle de la fonction, qui ne peut être visible que dans le corps de la fonction et accessible directement. L'attribut length et l'attribut callee de l'objet

arguments sont les plus couramment utilisés :

• Utilisez l'attribut length pour obtenir le nombre de paramètres réels de la fonction. L'objet arguments n'est visible qu'à l'intérieur du corps de la fonction, donc arguments.length ne peut être utilisé qu'à l'intérieur du corps de la fonction.

• Utilisez l'attribut appelé pour faire référence à la fonction où se trouve l'objet arguments actuel. Utilisez l'attribut callee pour appeler la fonction elle-même dans le corps de la fonction. Dans les fonctions anonymes, l'attribut appelé est utile. Par exemple, il peut être utilisé pour concevoir des appels récursifs.

Exemple 1 : Obtenez le nombre de paramètres réels et de paramètres formels

Utilisez la propriété arguments.length pour obtenir le nombre de paramètres réels d'une fonction. Vous pouvez utiliser la propriété length de l'objet fonction pour obtenir le nombre de paramètres formels de la fonction. Cette propriété est une propriété en lecture seule et peut être utilisée à la fois à l'intérieur et à l'extérieur du corps de la fonction.

L'exemple suivant conçoit une fonction checkArg() pour vérifier si les paramètres formels et les paramètres réels d'une fonction sont cohérents. S'ils sont incohérents, une exception sera levée.

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，传入一个参数

Exemple 2 : modifiez la valeur du paramètre réel à l'intérieur de la fonction

Dans l'exemple suivant, utilisez une boucle for pour parcourir l'objet arguments, puis transmettez la valeur de la variable de boucle en arguments pour modifier la valeur réelle valeur du paramètre.

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

Exemple 3 : Modification du nombre de paramètres réels de la fonction

En modifiant la valeur de l'attribut length, vous pouvez également modifier le nombre de paramètres réels de la fonction. Lorsque la valeur de l'attribut de longueur augmente, la valeur réelle du paramètre ajoutée n'est pas définie ; si la valeur de l'attribut de longueur diminue, la valeur réelle du paramètre après la valeur de longueur sera ignorée.

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

Exemple 4 : Vérifiez si les paramètres transmis par l'utilisateur répondent aux exigences

Dans l'exemple suivant, utilisez arguments.callee pour obtenir la fonction anonyme, puis obtenez le nombre de paramètres formels de la fonction via l'attribut length de la fonction, et enfin comparer le nombre de paramètres réels et le nombre de paramètres formels pour vérifier si les paramètres transmis par l'utilisateur répondent aux exigences.

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 est équivalent au nom de la fonction. Dans l'exemple ci-dessus, arguments.callee est égal à f.

Application de l'objet arguments

Dans le développement réel, l'objet arguments est très utile. Une utilisation flexible de l'objet arguments peut améliorer la flexibilité d'utilisation des fonctions et améliorer les capacités d'adaptabilité et de correction d'erreurs des fonctions dans la programmation abstraite. Ce qui suit combine plusieurs exemples typiques pour démontrer l’application des arguments.

1) L'utilisation de l'objet arguments peut améliorer la flexibilité de l'application des fonctions. Par exemple, si le nombre de paramètres de la fonction est incertain ou si le nombre de paramètres de la fonction est grand et que vous ne souhaitez pas définir chaque paramètre formel un par un, vous pouvez omettre de définir les paramètres et utiliser directement l'objet arguments. dans le corps de la fonction pour accéder aux valeurs réelles des paramètres de la fonction appelante.

Exemple 1

L'exemple suivant définit une fonction de moyenne, qui utilise l'objet arguments pour calculer la moyenne des paramètres. Lorsque vous appelez une fonction, vous pouvez transmettre n'importe quel nombre de paramètres.

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

Exemple 2

Dans la conception de pages, il est souvent nécessaire de vérifier les valeurs saisies dans le formulaire. L'exemple suivant vérifie si la valeur saisie dans la zone de texte est une adresse e-mail légale.

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) L'objet arguments est un tableau de pseudo-classe, pas un tableau. Les valeurs des paramètres réels peuvent être parcourues ou accessibles via la propriété length et la syntaxe des crochets. Cependant, en appelant dynamiquement des méthodes, vous pouvez également utiliser des méthodes de tableau, telles que push, pop, slice, etc.

Exemple 3

Utilisez des arguments pour simuler une surcharge. Méthode de mise en œuvre : utilisez la valeur de l'attribut arguments.length pour déterminer le nombre et le type de paramètres réels et décider d'exécuter différents codes.

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"

Exemple 4

L'exemple suivant utilise la méthode d'appel dynamique pour laisser l'objet arguments appeler la méthode tableau slice(), qui peut convertir l'objet paramètre de fonction en tableau.

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

【Apprentissage recommandé : Tutoriel avancé javascript】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!