Posso desativar ECMAscript de modo estrito para funções específicas?

Question

Eu não encontrar nada sobre a minha pergunta aqui no MDC ou ECMAscript especificações.Provavelmente, alguém sabe mais "hacky" maneira de resolver isso.

Eu estou chamando "use strict" em cada arquivo javascript no meu ambiente.Todos os meus arquivos de começar como este

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

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

Agora, eu tenho uma função personalizada que trata de erros.Que funções usa o .caller propriedade para fornecer um contexto rastreamento de pilha.Este aspecto:

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

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

    return _ret;
}());

Mas, é claro, no modo restrito .caller é um não-apagável hélice que lança ao ser recuperado.Então a minha pergunta é, alguém está consciente de forma a desativar estrito mais a função "sábio" ?

"use strict"; é herdada por todas as funções depois que ele foi chamado.Agora temos a possibilidade de usar apenas o modo restrito em funções específicas, por apenas chamar "use strict"; no topo das pessoas, mas há uma maneira para alcançar o oposto ?

Answer 1

Não, você não pode desativar o modo restrito por função.

É importante compreender de que modo estrito funciona lexicalmente;significado — afeta a declaração de função, não de execução.Qualquer função declarado dentro de um estrito código torna-se uma estrita função de si mesmo.Mas não qualquer função chamado de dentro de um estrito código é necessariamente rígida:

(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 como podemos definir a função fora do estrito código e, em seguida, passar para a função estrita.

Você pode fazer algo semelhante no seu exemplo — têm um objeto com o "malfeito" funções e, em seguida, passar o objeto para que o estrito imediatamente invocada a função.Claro, que não funciona se "desleixado" funções de variáveis de referência a partir de dentro principal função de wrapper.

Observe também que indireta eval — sugerido por alguém — realmente não vai ajudar aqui.Tudo o que ele faz é executar código no contexto global.Se você tentar chamar uma função que está definida localmente, indiretos eval mesmo não vai encontrá-lo:

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

})();

Essa confusão sobre a global eval provavelmente vem do fato de que a global eval pode ser usado para obter acesso ao objeto global partir de dentro, de modo estrito (que não é apenas acessível através de this mais):

(function(){
  "use strict";

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

Mas voltando à pergunta...

Você pode enganar e declarar uma nova função por meio de Function construtor — o que acontece não herdam rigor, mas que dependeria de (não-padrão) função descompilação e você gostaria de perder a capacidade de fazer referência a variáveis exterior.

(function(){
  "use strict";

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

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

  sneaky();
})();

Note que o FF4+ parece em desacordo com a especificação (de que eu posso dizer) e incorretamente marca função criada através Function como rigoroso.Isto não acontece em outros estrita-de modo a apoiar as implementações de (como o Chrome, 12+, IE10, o WebKit).

Answer 2

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

(...) De Modo estrito não é imposta no não-estrita funções que são chamados dentro do corpo de um rigoroso função (ou porque eles estavam passado como ou argumentos invocados usando call ou apply).

Então, se você configurar o erro de métodos em um arquivo diferente, sem de modo estrito, e, em seguida, passá-las como um 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)

...ele deve funcionar.

Answer 3

Uma alternativa é simplesmente fazer isso

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