¿Puedo desactivar el modo estricto de ECMAscript para funciones específicas?

Question

No encuentro nada sobre mi pregunta aquí en MDC o en las especificaciones de ECMAscript.Probablemente alguien conozca una forma más "hacky" de resolver esto.

estoy llamando "use strict" en cada archivo javascript en mi entorno.Todos mis archivos comienzan así.

(function(win, doc, undef) {
    "use strict";

    // code & functions
}(window, window.document));

Ahora tengo una función personalizada que maneja errores.Esas funciones utilizan el .caller propiedad para proporcionar un seguimiento de la pila de contexto.Se ve como esto:

var chain = (function() {
    var _parent = _error,
        _ret = '';

    while( _parent.caller ) {
        _ret += ' -> ' + _parent.caller.name;
        _parent = _parent.caller;
    }

    return _ret;
}());

Pero claro, en modo estricto. .caller es un accesorio no eliminable que se lanza cuando se recupera.Entonces mi pregunta es, ¿alguien sabe cómo desactivar ¿Estrictamente más "funcional"?

"use strict"; es heredado por todas las funciones después de ser llamado.Ahora tenemos la posibilidad de usar el modo estricto en funciones específicas simplemente llamando "use strict"; en la cima de ellos, pero ¿hay alguna manera de lograr lo contrario?

Answer 1

No, no puedes desactivar el modo estricto por función.

Es importante entender que el modo estricto funciona léxicamente;es decir, afecta la declaración de la función, no la ejecución.Cualquier función declarado dentro del código estricto se convierte en una función estricta en sí misma.Pero no cualquier función llamado desde dentro del código estricto es necesariamente estricto:

(function(sloppy) {
  "use strict";

   function strict() {
     // this function is strict, as it is _declared_ within strict code
   }

   strict();
   sloppy();

})(sloppy);

function sloppy(){
  // this function is not strict as it is _declared outside_ of strict code
}

Observe cómo podemos definir la función. fuera del código estricto y luego páselo a la función que es estricta.

Puede hacer algo similar en su ejemplo: tener un objeto con funciones "descuidadas" y luego pasar ese objeto a esa función estricta invocada inmediatamente.Por supuesto, eso no funcionará si las funciones "descuidadas" necesitan hacer referencia a variables desde la función contenedora principal.

También tenga en cuenta que evaluación indirecta (sugerido por otra persona) realmente no ayudará aquí.Todo lo que hace es ejecutar código en un contexto global.Si intentas llamar a una función definida localmente, la evaluación indirecta ni siquiera la encontrará:

(function(){
  "use strict";

  function whichDoesSomethingNaughty(){ /* ... */ }

  // ReferenceError as function is not globally accessible
  // and indirect eval obviously tries to "find" it in global scope
  (1,eval)('whichDoesSomethingNaughty')();

})();

Esta confusión sobre la evaluación global probablemente proviene del hecho de que la evaluación global se puede usar para obtener acceso a un objeto global desde el modo estricto (al que no se puede acceder simplemente a través de this ya no):

(function(){
  "use strict";

  this; // undefined
  (1,eval)('this'); // global object
})();

Pero volvamos a la pregunta...

Puedes hacer trampa y declarar una nueva función a través de Function constructor - lo que le sucede a no heredar rigor, pero eso dependería de la descompilación de funciones (no estándar) y usted perder la capacidad de hacer referencia a variables externas.

(function(){
  "use strict";

  function strict(){ /* ... */ }

  // compile new function from the string representation of another one
  var sneaky = Function('return (' + strict + ')()');

  sneaky();
})();

Tenga en cuenta que FF4+ parece no estar de acuerdo con las especificaciones (por lo que puedo decir) y marca incorrectamente la función creada mediante Function tan estricto.Esto no sucede en otros implementaciones de soporte de modo estricto (como Chrome 12+, IE10, WebKit).

Answer 2

(De http://javascriptweblog.wordpress.com/2011/05/03/javascript-strict-mode/)

(...) El modo estricto no se aplica en funciones que no son de rich que se invocan dentro del cuerpo de una función estricta (ya sea porque se aprobaron como argumentos o se invocaron usando call o apply).

Entonces, si configura los métodos de error en un archivo diferente, sin modo estricto, y luego los pasa como parámetro, así:

var test = function(fn) {
  'use strict';
  fn();
}

var deleteNonConfigurable = function () {
  var obj = {};
  Object.defineProperty(obj, "name", {
    configurable: false
  });
  delete obj.name; //will throw TypeError in Strict Mode
}

test(deleteNonConfigurable); //no error (Strict Mode not enforced)

...deberia de funcionar.

Answer 3

Una alternativa es simplemente hacer esto.

var stack;
if (console && console.trace) {
     stack = console.trace();
} else {
    try {
        var fail = 1 / 0;
    } catch (e) {
        if (e.stack) {
            stack = e.stack;
        } else if (e.stacktrace) {
            stack = e.stacktrace;
        }
    }
}
// have fun implementing normalize.
return normalize(stack);