Notes d'étude Javascript - Fonctions (4) : arguments object_basic knowledge

Chaque fonction Javascript peut accéder à une variable spéciale dans sa propre portée : les arguments. Cette variable contient une liste de tous les arguments passés à la fonction.
L'objet arguments n'est pas un tableau. Bien que syntaxiquement, il ait les mêmes fonctionnalités qu’un tableau, il possède par exemple une propriété length. Mais il n’hérite pas d’Array.prototype, en fait, c’est un objet.
Par conséquent, nous ne pouvons pas utiliser directement certaines méthodes de tableau telles que push, pop ou slice sur les arguments. Donc, pour utiliser ces méthodes, nous devons le convertir en un véritable tableau.

Convertir en tableau

Le code suivant renverra un tableau contenant tous les éléments de l'objet arguments.

Array.prototype.slice.call(arguments);
Étant donné que la conversion est très lente, cela n'est pas recommandé dans les programmes dont les performances sont critiques.

Paramètres de réussite

Ce qui suit est une méthode recommandée pour transmettre l'objet arguments d'une fonction à une autre.

Copier le code Le code est le suivant :

fonction foo() {
bar.apply(null, arguments);
>
barre de fonctions (a, b, c) {
// fais des trucs ici
>

Une autre méthode intelligente consiste à utiliser call et apply en même temps pour créer rapidement une méthode externe non liée.

Copier le code Le code est le suivant :

fonction Foo() {}
Foo.prototype.method = fonction (a, b, c) {
console.log(this, a, b, c);
};
// Créer une version indépendante de "méthode"
// Il prend les paramètres : this, arg1, arg2...argN
Foo.method = function() {
// Résultat : Foo.prototype.method.call(this, arg1, arg2... argN)
Function.call.apply(Foo.prototype.method, arguments);
};

La relation entre les paramètres de fonction et l'attribut arguments

L'objet

arguments crée des méthodes getter et setter à la fois pour ses propres propriétés et pour les paramètres formels de ses fonctions.
Par conséquent, la modification des paramètres formels d’une fonction affectera les valeurs des propriétés de l’objet arguments correspondant, et vice versa.

Copier le code Le code est le suivant :

fonction foo(a, b, c) {
arguments[0] = 2;
une; // 2
b = 4;
arguments[1]; // 4
var d = c;
d = 9;
c;//3
>
foo(1, 2, 3);

Problèmes de performances

les arguments ne seront pas créés dans seulement deux situations, l'une est déclarée comme variable locale à l'intérieur de la fonction et l'autre est utilisée comme paramètre formel de la fonction. Sinon, l'objet arguments est toujours créé.
Étant donné que les méthodes getter et setter sont toujours créées avec l'objet arguments, l'utilisation des arguments elle-même a peu d'impact sur les performances.
Cependant, il existe une situation qui affecte sérieusement les performances de Javascript, à savoir l'utilisation de arguments.callee.

Copier le code Le code est le suivant :

fonction foo() {
arguments.callee; // faire quelque chose avec cet objet fonction
arguments.callee.caller; // et l'objet fonction appelant
>
fonction bigLoop() {
pour (var je = 0; je < 100000; je ) {
foo(); // Serait normalement intégré...
>
>

Dans le code ci-dessus, la fonction foo n'est plus une simple extension en ligne, car elle a besoin de se connaître elle-même et de connaître son appelant. Cela annule non seulement le gain de performances apporté par l'expansion en ligne, mais détruit également l'encapsulation de la fonction, car la fonction elle-même peut devoir dépendre d'un contexte d'appel spécifique.
Par conséquent, il est recommandé d’essayer de ne pas utiliser arguments.callee.

Ce qui précède concerne l'objet arguments Javascript. Le comprenez-vous bien, en termes simples ?

les arguments font référence à l'objet paramètre de la fonction (faisant référence aux paramètres réels transmis)

arguments.length fait référence à la longueur de l'objet paramètre de la fonction
arguments[i] fait référence à la valeur du i-ième paramètre (le premier est 0)