¿Por qué la propiedad argumentos.callee.caller está en desuso en JavaScript?

¿Por qué la arguments.callee.callerpropiedad quedó en desuso en JavaScript?

Fue agregado y luego desaprobado en JavaScript, pero fue omitido por completo por ECMAScript. Algunos navegadores (Mozilla, IE) siempre lo han admitido y no tienen planes en el mapa para eliminar el soporte. Otros (Safari, Opera) han adoptado soporte para él, pero el soporte en navegadores antiguos no es confiable.

¿Hay una buena razón para poner esta valiosa funcionalidad en el limbo?

(O, alternativamente, ¿hay una mejor manera de controlar la función de llamada?)

Las primeras versiones de JavaScript no permitían expresiones de funciones con nombre, y por eso no pudimos hacer una expresión de función recursiva:

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

Para evitar esto, arguments.calleese agregó para que pudiéramos hacer:

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

Sin embargo, esta fue realmente una solución realmente mala, ya que esto (junto con otros argumentos, llamadas y problemas de llamadas) hace que la reclinación de cola y la cola sean imposibles en el caso general (puede lograrlo en casos seleccionados a través del rastreo, etc., pero incluso el mejor código es subóptimo debido a controles que de otra forma no serían necesarios). El otro problema importante es que la llamada recursiva tendrá un thisvalor diferente , por ejemplo:

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

De todos modos, EcmaScript 3 resolvió estos problemas al permitir expresiones de funciones con nombre, por ejemplo:

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

Esto tiene numerosos beneficios:

• La función se puede llamar como cualquier otra dentro de su código.

• No contamina el espacio de nombres.

• El valor de thisno cambia.

• Es más eficiente (acceder al objeto de argumentos es costoso).

Whoops

Me acabo de dar cuenta de que, además de todo lo demás, la pregunta se refería arguments.callee.caller, o más específicamente Function.caller.

En cualquier momento puede encontrar la llamada más profunda de cualquier función en la pila, y como dije anteriormente, mirar la pila de llamadas tiene un efecto importante: hace que una gran cantidad de optimizaciones sea imposible o mucho más difícil.

P.ej. Si no podemos garantizar que una función fno llame a una función desconocida, entonces no es posible en línea f. Básicamente significa que cualquier sitio de llamadas que puede haber sido trivialmente inlinable acumula una gran cantidad de guardias, tome:

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

Si el intérprete js no puede garantizar que todos los argumentos proporcionados sean números en el momento en que se realiza la llamada, debe insertar verificaciones para todos los argumentos antes del código en línea, o no puede en línea la función.

Ahora, en este caso particular, un intérprete inteligente debería ser capaz de reorganizar las comprobaciones para que sean más óptimas y no verificar ningún valor que no se utilizaría. Sin embargo, en muchos casos eso simplemente no es posible y, por lo tanto, es imposible alinearse.

arguments.callee.callerno está en desuso, aunque hace uso de la propiedad. ( solo le dará una referencia a la función actual)Function.callerarguments.callee

• Function.caller, aunque no es estándar según ECMA3, se implementa en todos los principales navegadores actuales .
• arguments.caller está en desuso a favor y no se implementa en algunos de los principales navegadores actuales (por ejemplo, Firefox 3).Function.caller

Por lo tanto, la situación es menos que ideal, pero si desea acceder a la función de llamada en Javascript en todos los principales navegadores, puede usar la propiedad, ya sea accediendo directamente en una referencia de función con nombre o desde una función anónima a través de la propiedad.Function.callerarguments.callee

Es mejor usar funciones nombradas que argumentos.callee:

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

es mejor que

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

La función nombrada tendrá acceso a su llamador a través de la propiedad llamante :

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

que es mejor que

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

La desaprobación se debe a los principios de diseño actuales de ECMAScript .

Solo una extensión. El valor de "esto" cambia durante la recursión. En el siguiente ejemplo (modificado), factorial obtiene el objeto {foo: true}.

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

El factorial llamado primera vez obtiene el objeto, pero esto no es cierto para las llamadas recursivas.