我可以为特定函数禁用 ECMAscript 严格模式吗？

在 MDC 或 ECMAscript 规范中，我没有找到任何关于我的问题的内容。也许有人知道一个更“骇客”的方法来解决这个问题。

我在我的环境中的每个 javascript 文件上调用 "use strict"

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


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

现在，我有一个自定义函数来处理错误。该函数使用 .caller属性提供 上下文堆栈跟踪。看起来像这样:

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


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


return _ret;
}());

当然，在严格模式下，.caller是一个不可删除的道具，当检索时抛出。所以我的问题是，是否有人知道如何严格的 关闭更“功能明智”？

"use strict";在调用后被所有函数继承。现在我们有可能在特定函数中使用严格模式，只需在函数顶部调用 "use strict";，但是有没有相反的方法呢？

58051 次浏览
小开

An alternative is simply doing this

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

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

(...) Strict Mode is not enforced on non-strict functions that are invoked inside the body of a strict function (either because they were passed as arguments or invoked using call or apply).

So if you setup the error methods in a different file, without strict mode, and then pass them as a parameter, like this:

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)

...it should work.

小开
最佳答案

No, you can't disable strict mode per function.

It's important to understand that strict mode works lexically; meaning — it affects function declaration, not execution. Any function declared within strict code becomes a strict function itself. But not any function called from within strict code is necessarily strict:

(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
}

Notice how we can define function outside of strict code and then pass it into the function that's strict.

You can do something similar in your example — have an object with "sloppy" functions, then pass that object to that strict immediately invoked function. Of course, that won't work if "sloppy" functions need to reference variables from within main wrapper function.

Also note that indirect eval — suggested by someone else — won't really help here. All it does is execute code in global context. If you try to call a function that's defined locally, indirect eval won't even find it:

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


})();

This confusion about global eval probably comes from the fact that global eval can be used to get access to global object from within strict mode (which isn't simply accessible via this anymore):

(function(){
"use strict";


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

But back to the question...

You can kind of cheat and declare a new function via Function constructor — which happens to not inherit strictness, but that would rely on (non-standard) function decompilation and you would lose ability to reference outer variables.

(function(){
"use strict";


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


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


sneaky();
})();

Note that FF4+ seems to disagree with spec (from what I can tell) and incorrectly marks function created via Function as strict. This doesn't happen in other strict-mode-supporting implementations (like Chrome 12+, IE10, WebKit).


提交答案