Pourquoi la propriété arguments.callee.caller a-t-elle été déconseillée en JavaScript?

Pourquoi la arguments.callee.callerpropriété a- t-elle été dépréciée en JavaScript?

Il a été ajouté puis déconseillé en JavaScript, mais il a été complètement omis par ECMAScript. Certains navigateurs (Mozilla, IE) l'ont toujours pris en charge et n'ont aucun plan sur la carte pour supprimer le support. D'autres (Safari, Opera) l'ont adopté, mais la prise en charge sur les navigateurs plus anciens n'est pas fiable.

Y a-t-il une bonne raison de mettre cette précieuse fonctionnalité dans les limbes?

(Ou alternativement, existe-t-il une meilleure façon de saisir la poignée de la fonction d'appel?)

Les premières versions de JavaScript ne permettaient pas les expressions de fonction nommées, et à cause de cela, nous ne pouvions pas créer une expression de fonction récursive:

 // This snippet will work:
 function factorial(n) {
     return (!(n>1))? 1 : factorial(n-1)*n;
 }
 [1,2,3,4,5].map(factorial);


 // But this snippet will not:
 [1,2,3,4,5].map(function(n) {
     return (!(n>1))? 1 : /* what goes here? */ (n-1)*n;
 });

Pour contourner cela, a arguments.calleeété ajouté afin que nous puissions faire:

 [1,2,3,4,5].map(function(n) {
     return (!(n>1))? 1 : arguments.callee(n-1)*n;
 });

Cependant, c'était en fait une très mauvaise solution car cela (en conjonction avec d'autres arguments, les appels et les problèmes de l'appelant) rend l'inline et la récursivité de la queue impossibles dans le cas général (vous pouvez y parvenir dans certains cas en traçant etc., mais même le meilleur code est sous-optimal en raison de vérifications qui ne seraient pas nécessaires autrement). L'autre problème majeur est que l'appel récursif obtiendra un autrethis valeur , par exemple:

var global = this;
var sillyFunction = function (recursed) {
    if (!recursed)
        return arguments.callee(true);
    if (this !== global)
        alert("This is: " + this);
    else
        alert("This is the global");
}
sillyFunction();

Quoi qu'il en soit, EcmaScript 3 a résolu ces problèmes en autorisant les expressions de fonction nommées, par exemple:

 [1,2,3,4,5].map(function factorial(n) {
     return (!(n>1))? 1 : factorial(n-1)*n;
 });

Cela présente de nombreux avantages:

• La fonction peut être appelée comme n'importe quelle autre depuis votre code.

• Il ne pollue pas l'espace de noms.

• La valeur de thisne change pas.

• C'est plus performant (accéder à l' objet arguments coûte cher).

Oups,

Je viens de réaliser qu'en plus de tout le reste, la question portait sur arguments.callee.caller, ou plus précisément Function.caller.

À tout moment, vous pouvez trouver l'appelant le plus profond de n'importe quelle fonction sur la pile, et comme je l'ai dit ci-dessus, regarder la pile d'appels a un seul effet majeur: cela rend un grand nombre d'optimisations impossibles, ou beaucoup plus difficiles.

Par exemple. si nous ne pouvons pas garantir qu'une fonction fn'appellera pas une fonction inconnue, alors il n'est pas possible de s'aligner f. Fondamentalement, cela signifie que tout site d'appel qui peut avoir été trivialement inline accumule un grand nombre de gardes, prenez:

 function f(a, b, c, d, e) { return a ? b * c : d * e; }

Si l'interpréteur js ne peut pas garantir que tous les arguments fournis sont des nombres au moment de l'appel, il doit soit insérer des vérifications pour tous les arguments avant le code intégré, soit il ne peut pas aligner la fonction.

Maintenant, dans ce cas particulier, un interpréteur intelligent devrait être en mesure de réorganiser les contrôles pour être plus optimal et de ne vérifier aucune valeur qui ne serait pas utilisée. Cependant, dans de nombreux cas, ce n'est tout simplement pas possible et il devient donc impossible de s'aligner.

arguments.callee.callern'est pas déconseillé, bien qu'il utilise la propriété. ( vous donnera juste une référence à la fonction actuelle)Function.callerarguments.callee

• Function.caller, bien que non standard selon ECMA3, est implémenté sur tous les principaux navigateurs actuels .
• arguments.caller est déconseillé en faveur de et n'est pas implémenté dans certains des principaux navigateurs actuels (par exemple Firefox 3).Function.caller

La situation n'est donc pas idéale, mais si vous souhaitez accéder à la fonction appelante en Javascript sur tous les principaux navigateurs, vous pouvez utiliser la propriété, soit accessible directement sur une référence de fonction nommée, soit à partir d'une fonction anonyme via la propriété.Function.callerarguments.callee

Il vaut mieux utiliser des fonctions nommées que arguments.callee:

 function foo () {
     ... foo() ...
 }

est mieux que

 function () {
     ... arguments.callee() ...
 }

La fonction nommée aura accès à son appelant via la propriété de l' appelant :

 function foo () {
     alert(foo.caller);
 }

ce qui est mieux que

 function foo () {
     alert(arguments.callee.caller);
 }

La dépréciation est due aux principes de conception actuels d'ECMAScript .

Juste une extension. La valeur de "ceci" change pendant la récursivité. Dans l'exemple suivant (modifié), factorial obtient l'objet {foo: true}.

[1,2,3,4,5].map(function factorial(n) {
  console.log(this);
  return (!(n>1))? 1 : factorial(n-1)*n;
},     {foo:true}     );

la factorielle appelée la première fois obtient l'objet, mais ce n'est pas le cas pour les appels récursifs.