Warum wurde die Eigenschaft rules.callee.caller in JavaScript nicht mehr unterstützt?

Warum wurde die arguments.callee.callerEigenschaft in JavaScript nicht mehr unterstützt?

Es wurde hinzugefügt und dann in JavaScript veraltet, aber von ECMAScript insgesamt weggelassen. Einige Browser (Mozilla, IE) haben dies immer unterstützt und haben keine Pläne auf der Karte, die Unterstützung zu entfernen. Andere (Safari, Opera) haben Unterstützung dafür übernommen, aber die Unterstützung in älteren Browsern ist unzuverlässig.

Gibt es einen guten Grund, diese wertvolle Funktionalität in die Schwebe zu bringen?

(Oder gibt es alternativ eine bessere Möglichkeit, die aufrufende Funktion in den Griff zu bekommen?)

Frühere Versionen von JavaScript erlaubten keine benannten Funktionsausdrücke, und aus diesem Grund konnten wir keinen rekursiven Funktionsausdruck erstellen:

 // 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;
 });

Um dies zu umgehen, arguments.calleewurde hinzugefügt, damit wir Folgendes tun können:

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

Dies war jedoch tatsächlich eine wirklich schlechte Lösung, da dies (in Verbindung mit anderen Argumenten, Angerufenen und Anruferproblemen) das Inlining und die Schwanzrekursion im allgemeinen Fall unmöglich macht (Sie können dies in ausgewählten Fällen durch Nachverfolgung usw. erreichen, aber auch durch den besten Code ist aufgrund von Prüfungen, die sonst nicht notwendig wären, suboptimal). Das andere Hauptproblem ist, dass der rekursive Aufruf einen anderen thisWert erhält, zum Beispiel:

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();

Wie auch immer, EcmaScript 3 hat diese Probleme gelöst, indem benannte Funktionsausdrücke zugelassen wurden, z.

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

Dies hat zahlreiche Vorteile:

• Die Funktion kann wie jede andere in Ihrem Code aufgerufen werden.

• Der Namespace wird nicht verschmutzt.

• Der Wert von thisändert sich nicht.

• Es ist performanter (der Zugriff auf das Argumentobjekt ist teuer).

Hoppla,

Ich habe gerade festgestellt, dass es neben allem anderen um die Frage ging arguments.callee.caller, genauer gesagt Function.caller.

Zu jedem Zeitpunkt können Sie den tiefsten Aufrufer einer Funktion auf dem Stapel finden, und wie ich oben sagte, hat das Betrachten des Aufrufstapels einen einzigen Haupteffekt: Es macht eine große Anzahl von Optimierungen unmöglich oder viel schwieriger.

Z.B. Wenn wir nicht garantieren können, dass eine Funktion fkeine unbekannte Funktion aufruft, kann nicht inline geschaltet werden f. Grundsätzlich bedeutet dies, dass jede Anrufstelle, die möglicherweise trivial inlinierbar war, eine große Anzahl von Wachen ansammelt. Nehmen Sie:

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

Wenn der js-Interpreter zum Zeitpunkt des Aufrufs nicht garantieren kann, dass alle angegebenen Argumente Zahlen sind, muss er entweder vor dem Inline-Code Überprüfungen für alle Argumente einfügen oder die Funktion nicht einbinden.

In diesem speziellen Fall sollte ein intelligenter Interpreter in der Lage sein, die Prüfungen neu anzuordnen, um sie optimaler zu gestalten, und keine Werte zu prüfen, die nicht verwendet würden. In vielen Fällen ist dies jedoch einfach nicht möglich und daher wird es unmöglich, Inline zu erstellen.

arguments.callee.callerist nicht veraltet, obwohl es die Eigenschaft nutzt . ( gibt Ihnen nur einen Verweis auf die aktuelle Funktion)Function.callerarguments.callee

• Function.callerObwohl gemäß ECMA3 nicht standardisiert, ist es in allen gängigen Hauptbrowsern implementiert .
• arguments.caller wird zugunsten von abgelehnt und ist in einigen aktuellen Hauptbrowsern (z. B. Firefox 3) nicht implementiert.Function.caller

Die Situation ist also nicht ideal, aber wenn Sie über alle gängigen Browser auf die aufrufende Funktion in Javascript zugreifen möchten, können Sie die Eigenschaft verwenden, auf die entweder direkt über eine benannte Funktionsreferenz oder über die Eigenschaft innerhalb einer anonymen Funktion zugegriffen wird .Function.callerarguments.callee

Es ist besser, benannte Funktionen als Argumente zu verwenden.

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

ist besser als

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

Die benannte Funktion hat über die Caller- Eigenschaft Zugriff auf ihren Aufrufer :

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

das ist besser als

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

Die Abschreibung ist auf die aktuellen ECMAScript- Gestaltungsprinzipien zurückzuführen .

Nur eine Erweiterung. Der Wert von "this" ändert sich während der Rekursion. Im folgenden (modifizierten) Beispiel erhält Fakultät das Objekt {foo: true}.

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

Beim ersten Aufruf von Fakultät wird das Objekt abgerufen, dies gilt jedoch nicht für rekursive Aufrufe.