¿Por qué fueron las discusiones?callee.propiedad de llamada obsoleta en JavaScript?

Las primeras versiones de JavaScript no permitían expresiones de función con nombre, y debido a eso no podíamos 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.callee se 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, esto fue realmente una solución muy mala, ya que esto (junto con otros argumentos, llamadas y problemas de llamadas) hacen que la recursión de cola e inlining sea imposible en el caso general (se puede lograr en casos seleccionados a través del rastreo, etc., pero incluso el mejor código no es óptimo debido a comprobaciones que de otro modo no serían necesarias). El otro problema importante es que la llamada recursiva obtendrá un valor this 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 función 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 desde el interior de su código.

• No contamina la espacio de nombres.

• El valor de this no cambia.

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

Whoops,

Acaba de darse cuenta de que además de todo lo demás la pregunta era sobre arguments.callee.caller, o más específicamente Function.caller.

En cualquier punto en el tiempo se puede encontrar la llamada más profunda de cualquier función en la pila, y como he dicho anteriormente, mirando la pila de llamadas tiene una sola efecto mayor: Hace que un gran número de optimizaciones sea imposible, o mucho más difícil.

Eg. si no podemos garantizar que una función f no llamar a una función desconocida, entonces no es posible en línea f. Básicamente significa que cualquier sitio de llamada que pueda haber sido trivialmente inlinable acumula un gran número de guardias, tome:

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

Si el intérprete de js no puede garantizar que todos los argumentos proporcionados sean números en el punto en que se realiza la llamada, necesita insertar comprobaciones para todos los argumentos antes del código inlined,o no puede insertar 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 comprobar ningún valor que no se utilizaría. Sin embargo, en muchos casos eso no es posible y, por lo tanto, se vuelve imposible insertarlo.