javascript - the - use strict java script

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

Question

No encuentro nada sobre mi pregunta aquí en MDC o en las especificaciones de ECMAscript. Probablemente alguien sepa 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 los errores. Esa función utiliza la propiedad .caller 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, por supuesto, en modo estricto .caller es un apoyo no eliminable que se lanza cuando se recupera. Entonces mi pregunta es, ¿hay alguien consciente de la forma de desactivar estrictamente más "función-sabio"?

"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 parte superior de esos, pero ¿hay alguna manera de lograr lo opuesto?

Answer 1

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

(...) El modo estricto no se aplica en las funciones no estrictas que se invocan dentro del cuerpo de una función estricta (ya sea porque se pasaron como argumentos o se invocaron mediante call o apply ).

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

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 2

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

Es importante entender que el modo estricto funciona léxicamente ; significado - afecta la declaración de la función, no la ejecución. Cualquier función declarada dentro de un código estricto se convierte en una función estricta en sí misma. Pero ninguna función llamada dentro de un código estricto es necesariamente estricta:

(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 pasarla a la función que es estricta.

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

También tenga en cuenta que la evaluación indirecta , sugerida por otra persona, no será de gran ayuda aquí. Todo lo que hace es ejecutar código en contexto global. Si intenta invocar 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 provenga del hecho de que la evaluación global se puede usar para obtener acceso a un objeto global desde el modo estricto (que no es simplemente accesible a través de this más):

(function(){
  "use strict";

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

Pero volviendo a la pregunta ...

Puede hacer trampa y declarar una nueva función mediante el constructor de Function , que no hereda el rigor, pero que dependería de la descompilación de funciones (no estándar) y perdería la capacidad de hacer referencia a las 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 estar en desacuerdo con la función de especificación (de lo que puedo decir) y marca incorrectamente creada a través de la Function como estricta. Esto no ocurre en otras implementaciones que admiten modo estricto (como Chrome 12+, IE10, WebKit).

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