Explication détaillée des arguments en js

Lorsque nous appelons une fonction en js, nous transmettons souvent certains paramètres à la fonction. js stocke tous les paramètres passés à la fonction dans quelque chose appelé arguments, alors qu'est-ce que c'est exactement ?

Tout en js est un objet, même les fonctions de tableau et de chaîne sont des objets. Donc, cette chose appelée arguments est également un objet, et c'est un objet spécial. Son nom d'attribut est basé sur la séquence des paramètres transmis. Le nom d'attribut du premier paramètre est « 0 » et le nom d'attribut du second. Le paramètre est '1', et ainsi de suite, et il a également un attribut de longueur, qui stocke le nombre de paramètres de fonction actuellement transmis. Nous appelons souvent ce type d'objet un objet de type tableau. Les objets de type tableau et les tableaux sont tous deux nés d'objets, mais les tableaux sont le frère aîné et ont beaucoup plus de jouets (méthodes) que les objets de type tableau ne sont que les frères plus jeunes qui ressemblent beaucoup à des tableaux.

Attendez une minute, ne viens-je pas de dire que les tableaux sont aussi des objets ? Qu'est-ce que cet objet semblable à un tableau maintenant ? Il n'y a aucun moyen, js est tellement flexible. Cet objet de type tableau stocke non seulement les paramètres transmis à la fonction, mais possède également d'autres attributs, qui seront discutés un par un plus tard.

Parce que les objets de type tableau et les tableaux ont beaucoup en commun, nous pouvons souvent utiliser la méthode d'appel pour permettre à l'objet de type tableau d'utiliser également certaines des méthodes du tableau, c'est-à-dire laisser le frère cadet jouer avec les jouets de son frère aîné, comme... , n'allons pas trop loin, cet article ne parle que d'arguments. Si vous voulez en savoir plus sur la façon dont les objets empruntent les méthodes de tableau, veuillez vous référer à cet article.

---

Attributs des arguments

Jetons ensuite un coup d'œil à ce qu'il y a dans l'objet arguments, qu'il s'agisse d'un mulet ou d'un cheval.

function showargs() {
    console.log( arguments );
}

showargs(1,2,3,4,5);

Ensuite, nous utilisons console.log pour afficher l'objet arguments sur la console. Je dois dire ici que l'outil de console de Chrome est extrêmement simple à utiliser (je ne suis pas ici pour faire de la publicité).

<br/>

Ici, nous pouvons voir que l'objet arguments stocke les cinq paramètres que j'ai transmis sous la forme d'un tableau, et enregistre également le nombre (longueur) des paramètres réels que j'ai transmis à la fonction. Et nous pouvons voir que ==_ proto _== des arguments object pointe vers object, ce qui montre également qu'il s'agit d'un objet de type tableau, pas d'un tableau.

Avec cet objet, lorsque nous écrirons des fonctions à l'avenir, nous n'avons pas besoin de spécifier les noms de paramètres pour tous les paramètres formels, puis d'obtenir les paramètres via les noms de paramètres. Nous pouvons directement utiliser l'objet arguments pour obtenir les paramètres réels. paramètres, donc n'est-ce pas beaucoup plus pratique ? <br/> Dans certaines langues, après avoir spécifié le nom du paramètre de la fonction, lorsque la fonction est appelée, il sera jugé si les paramètres actuellement transmis sont égaux au nombre de paramètres définis par la fonction. Sinon, une erreur. sera signalé, mais flexible js (pas moi, disons, js est vraiment flexible) et ne vérifiera pas si le nombre de paramètres passés à la fonction est égal au nombre de paramètres définis par la fonction. Donc afin de montrer (la simplicité du code), nous utilisons des arguments pour appeler des paramètres afin de ne pas confondre les noms de paramètres entre les différentes fonctions. De plus, afin de montrer (la rigueur du code), nous pouvons également utiliser des arguments pour déterminer si le nombre actuel de paramètres transmis est cohérent avec le nombre dont nous avons besoin.

Voici un exemple :

function add() {
    if( arguments.length == 2 ){        return arguments[0] + arguments[1];
    }else{        return '传入参数不合法';
    }
}

console.log( add(2,3) );
console.log( add(1,2,3) );

Regardez le résultat :

Enfin, nous pouvons également voir qu'il existe un autre argument appelé L'attribut de l'appelé, cet attribut représente une référence à la fonction courante. Pour faire simple, lorsque le code de la fonction que nous appelons stocké dans cet attribut est vraiment incompréhensible, il est temps pour console.log de montrer ses talents.

function showcallee() {
    var a = '这里是代码';    var b = '这是另一段代码';    var c = a + b;

    console.log(arguments.callee);    return c;
}
showcallee();

Êtes-vous aussi choqué que moi quand vous voyez le résultat ? N'est-ce pas le code que j'ai écrit arguments.callee complètement Ce code de cette fonction revient.

---

Quelques utilisations merveilleuses des arguments

1. Utiliser des arguments pour implémenter la surcharge des méthodes

Ci-dessous, nous utilisons l'objet arguments pour implémenter un relation entre les paramètres La fonction d'ajout, quel que soit le nombre de paramètres transmis, sera renvoyée après l'ajout des paramètres transmis.

function add() {
    var len = arguments.length,       
     sum = 0;    
     for(;len--;)
     {        sum += arguments[len];
    }    return sum;
}console.log( add(1,2,3) );  
 //6console.log( add(1,3) );     
 //4console.log( add(1,2,3,5,6,2,7) );   
 //26

Puisque js est un langage faiblement typé et n'a pas de mécanisme de surcharge, lorsque nous réécrivons une fonction, la fonction d'origine sera directement écrasée. Ici, nous pouvons utiliser des arguments pour déterminer les différentes opérations entrantes. sur le type et la quantité réels du paramètre, puis renvoient des valeurs différentes.

2. Utilisez arguments.callee pour implémenter la récursion

Voyons d'abord comment nous avons implémenté la récursion auparavant. Il s'agit d'une fonction qui règle les factorielles

function factorial(num) { 
    if(num<=1) { 
        return 1; 
    }else { 
        return num * factorial(num-1); 
    } 
}

Mais lorsque cette fonction devient une fonction anonyme, nous pouvons utiliser l'appelé pour récurer la fonction.

function factorial(num) { 
    if(num<=1) { 
        return 1; 
    }else { 
        return num * arguments.callee(num-1); 
    } 
}

这个方法虽然好用，但是有一点值得注意，ECMAScript4中为了限制js的灵活度，让js变得严格，新增了严格模式，在严格模式中我们被禁止不使用var来直接声明一个全局变量，当然这不是重点，重点是arguments.callee这个属性也被禁止了。不过这都不是事儿，ES6为我们新增了很多好用的变量声明方式和新的语法糖，作为一个时髦的前端，我们赶紧学习一些ES6的新语法吧。

相关推荐：

js中arguments.length解析

js函数的调用及有关隐式参数arguments和this的问题

JavaScript arguments 对象详解

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!