Série avancée JavaScript : objet arguments

• Convertir en tableau

• Passer les paramètres

• Mettre à jour automatiquement

• Performance Truth

Chaque fonction en JavaScript peut accéder à des arguments de variable spéciaux. Cette variable maintient la liste de tous les arguments passés à cette fonction.

La variable arguments n'est pas un tableau (Array). Bien que syntaxiquement, il ait la longueur de propriété liée au tableau, il n'hérite pas de Array.prototype et est en fait un objet.

(Remarque : puisque les arguments ont été définis comme une variable dans la fonction. Par conséquent, définir des arguments via le mot-clé var ou déclarer des arguments en tant que paramètre formel entraînera la non-création d'arguments natifs.)

Par conséquent, les méthodes de tableau standard telles que push, pop ou slice ne peuvent pas être utilisées sur la variable arguments. Bien qu'il soit possible d'utiliser une boucle for pour parcourir, afin de mieux utiliser la méthode tableau, il est préférable de la convertir en un véritable tableau.

Convertir en tableau

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

Array.prototype.slice.call(arguments);

Cette conversion est lente et n'est pas recommandée dans du code aux performances médiocres.

Passer des paramètres

Ce qui suit est la pratique recommandée pour passer des paramètres d'une fonction à une autre.

function foo() {
    bar.apply(null, arguments);
}
function bar(a, b, c) {
    // 干活
}

Une autre astuce consiste à utiliser call et apply ensemble, créant ainsi un wrapper de déliaison rapide.

function Foo() {}

Foo.prototype.method = function(a, b, c) {
    console.log(this, a, b, c);
};

// 创建一个解绑定的 "method"
// 输入参数为: this, arg1, arg2...argN
Foo.method = function() {

    // 结果: Foo.prototype.method.call(this, arg1, arg2... argN)
    Function.call.apply(Foo.prototype.method, arguments);
};

Note du traducteur : la fonction Foo.method ci-dessus a le même effet que le code suivant :

Foo.method = function() {
    var args = Array.prototype.slice.call(arguments);
    Foo.prototype.method.apply(args[0], args.slice(1));
}

Mise à jour automatiquement l'objet

arguments qu'il contient. Propriété et les paramètres formels de fonction créent des méthodes getter et setter.

Par conséquent, changer la valeur du paramètre formel affectera la valeur de l'objet arguments, et vice versa.

function foo(a, b, c) {
    arguments[0] = 2;
    a; // 2                                                           

    b = 4;
    arguments[1]; // 4

    var d = c;
    d = 9;
    c; // 3
}
foo(1, 2, 3)

Performance Truth

L'objet arguments est toujours créé, qu'il soit utilisé ou non, sauf dans deux cas particuliers - déclaré comme variable locale et comme paramètre formel. Les méthodes getters et setters des

arguments sont toujours créées ; donc l'utilisation d'arguments n'aura aucun impact sur les performances. Sauf si vous devez accéder plusieurs fois aux propriétés de l’objet arguments.

Note du traducteur : La description des arguments en mode strict dans MDC est utile pour notre compréhension. Veuillez regarder le code suivant :

// 阐述在 ES5 的严格模式下 `arguments` 的特性
function f(a) {
  "use strict";
  a = 42;
  return [a, arguments[0]];
}
var pair = f(17);
console.assert(pair[0] === 42);
console.assert(pair[1] === 17);

Cependant, il y a bel et bien une situation qui sera. affecte de manière significative les performances des moteurs JavaScript modernes. Cela utilise arguments.callee.

function foo() {
    arguments.callee; // do something with this function object
    arguments.callee.caller; // and the calling function object
}

function bigLoop() {
    for(var i = 0; i < 100000; i++) {
        foo(); // Would normally be inlined...
    }
}

Dans le code ci-dessus, foo n'est plus une simple fonction en ligne inline (Note du traducteur : cela fait référence à l'analyseur qui peut effectuer le traitement en ligne), car il a besoin de se connaître lui-même et d'être l'appelant. Non seulement cela annule le gain de performances des fonctions en ligne, mais cela interrompt l'encapsulation, de sorte que les fonctions peuvent désormais dépendre d'un contexte spécifique.

Il est donc fortement recommandé de ne pas utiliser arguments.callee et ses propriétés.

Ce qui précède est le contenu de la série avancée JavaScript—objet arguments. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !