Chaque fonction JavaScript peut accéder à une variable spéciale - arguments dans son portée. Cette variable contient une liste de tous les paramètres transmis à la fonction.
L'objet d'arguments n'est pas un tableau. Bien que syntaxiquement, il a le même endroit qu'un tableau, par exemple, il a la propriété de longueur. Mais il n'est pas hérité de l'array.prototype, en fait, c'est un objet.
Par conséquent, nous ne pouvons pas utiliser directement certaines méthodes de tableau pour les arguments, tels que Push, Pop ou Slice, etc. Ainsi, pour utiliser ces méthodes, nous devons le convertir en un vrai tableau.
Se convertir en un 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 vitesse de conversion est très lente, cela n'est pas recommandé dans les programmes avec des exigences de performance strictes.
Paramètres de passage
Voici une méthode plus recommandée pour passer l'objet d'arguments d'une fonction à une autre.
La copie de code est la suivante:
fonction foo () {
Bar.Apply (null, arguments);
}
barre de fonction (a, b, c) {
// Faites des trucs ici
}
Il existe une autre méthode intelligente, qui consiste à créer rapidement une méthode extérieure qui se soumet à l'utilisation de l'appel et à l'appliquer en même temps.
La copie de code est la suivante:
fonction foo () {}
Foo.prototype.method = fonction (a, b, c) {
console.log (ce, a, b, c);
};
// Créer une version non liée de "méthode"
// il prend les paramètres: ceci, 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 les attributs d'arguments
L'objet d'arguments crée des méthodes Getter et Setter pour ses propres propriétés et paramètres de fonction.
Par conséquent, la modification des paramètres formels de la fonction affectera les valeurs de propriété de l'objet d'arguments correspondants et vice versa.
La copie de code est la suivante:
fonction foo (a, b, c) {
arguments [0] = 2;
un; // 2
b = 4;
arguments [1]; // 4
var d = c;
d = 9;
C; // 3
}
foo (1, 2, 3);
Problèmes de performance
Les arguments ne seront pas créés dans seulement deux cas, l'un est déclaré comme une variable locale à l'intérieur de la fonction, et l'autre est utilisé comme paramètre formel de la fonction. Dans d'autres cas, l'objet des arguments sera toujours créé.
Étant donné que les méthodes Getter et Setter sont toujours créées avec la création d'objets d'arguments, l'utilisation d'arguments a peu d'effet sur les performances elle-même.
Cependant, il existe une situation qui affecte sérieusement les performances de JavaScript, qui consiste à utiliser des arguments.Callee.
La copie de code est la suivante:
fonction foo () {
arguments.Callee; // faire quelque chose avec cet objet de fonction
Arguments.Callee.Caller; // et l'objet de fonction d'appel
}
fonction bigloop () {
pour (var i = 0; i <100000; i ++) {
foo (); // serait normalement incliné ...
}
}
Dans le code ci-dessus, la fonction FOO n'est plus une simple extension en ligne, car elle doit se connaître et son appelant. Cela compense non seulement les améliorations des performances apportées par des extensions en ligne, mais compromet également l'encapsulation de la fonction, car la fonction elle-même peut avoir besoin de s'appuyer sur un fond d'appel spécifique.
Par conséquent, il est recommandé d'essayer de ne pas utiliser d'arguments.Callee.
Ce qui précède concerne l'objet JavaScript Arguments. Le savez-vous soigneusement? Mettre simplement
arguments se référer à l'objet de paramètre de la fonction (se réfère aux paramètres réels passés)
Arguments.Length fait référence à la longueur de l'objet de paramètre de la fonction.
Les arguments [i] se réfèrent à la valeur du i-tème paramètre (le premier est 0)