我想检查脚本是否已加载其他模块。

if (ModuleName) {
    // extend this module
}

但是，如果ModuleName不存在，那就是throw。

如果我知道那Global Object是什么，我可以使用它。

if (window.ModuleName) {
    // extend this module
}

但是，因为我希望我的模块与浏览器和工作node，rhino等等，我不能假设window。

据我了解，这在ES 5中无法使用"use strict";。

var MyGLOBAL = (function () {return this;}()); // MyGlobal becomes null

这也会因抛出异常而失败

var MyGLOBAL = window || GLOBAL

所以好像我已经离开了

try {
    // Extend ModuleName
} 
catch(ignore) {
}

这些情况都不会通过JSLint。

我有什么想念的吗？

好吧，您可以使用typeof运算符，并且如果标识符在范围链的任何位置都不存在，则不会抛出ReferenceError，而只会返回"undefined"：

if (typeof ModuleName != 'undefined') {
  //...
}

还要记住，this全局代码中的值是指全局对象，这意味着如果您的if声明位于全局上下文中，则只需检查即可this.ModuleName。

关于这项(function () { return this; }());技术，您是对的，在严格模式下，this值将仅为undefined。

在严格模式下，无论您身在何处，都有两种方法可以获取对Global对象的引用：

• 通过Function构造函数：

  var global = Function('return this')();
  

用Function构造函数创建的函数不会继承调用方的严格性，只有在以'use strict'指令开头的函数体中它们才是严格的，否则它们是非严格的。

此方法与任何ES3实现兼容。

• 通过间接eval调用，例如：

  "use strict";
  var get = eval;
  var global = get("this");
  

上面的方法之所以可行，是因为在ES5中，对的间接调用eval将全局环境用作评估代码的变量环境和词法环境。

查看有关输入评估码（步骤1）的详细信息。

但是请注意，最后一个解决方案不适用于ES3实现，因为对ES3的间接调用eval会将调用者的变量和词法环境用作eval代码本身的环境。

最后，您可能会发现检测是否支持严格模式很有用：

var isStrictSupported = (function () { "use strict"; return !this; })();

更新2019

对于当今的所有Webpack和Broccolis，Gulps和Grunts，TypeScript和AltScripts，以及create-react-apps等，这都是毫无用处的，但是如果您只使用普通的，旧的VanillaJS，并且想要制作同构，这可能是您最好的选择：

var global
try {
  global = Function('return this')();
} catch(e) {
  global = window;
}

即使在--use_strictin节点中使用时，Function构造函数调用也将起作用，因为Function构造函数始终在全局非严格范围内执行。

如果Function构造函数失败，那是因为您所在的浏览器eval被CSP标头禁用。

当然，与杰诺的方式（节点替换），它们也不允许该功能的构造，在这种情况下，它回到枚举对象，如global，module，exports，globalThis和window，然后鸭式检查这是全球详尽... ：-/

疯狂的一线解决方案（原始）：

var global = Function('return this')() || (42, eval)('this');

。

。

。

作品

• 在每个环境中（我测试过）
• 在严格模式下
• 甚至在嵌套范围内

更新2014年9月23日

如果最新浏览器中的HTTP标头明确禁止eval，则此操作现在可能会失败。

一种解决方法是尝试/捕获原始解决方案，因为只有浏览器才能运行此类JavaScript子集。

var global;

try {
  global = Function('return this')() || (42, eval)('this');
} catch(e) {
  global = window;
}

Example:
---

    (function () {

      var global = Function('return this')() || (42, eval)('this');
      console.log(global);

      // es3 context is `global`, es5 is `null`
      (function () {
        "use strict";

        var global = Function('return this')() || (42, eval)('this');
        console.log(global);

      }());

      // es3 and es5 context is 'someNewContext'
      (function () {

        var global = Function('return this')() || (42, eval)('this');
        console.log(global);

      }).call('someNewContext');

    }());

Tested:
---

  * Chrome v12
  * Node.JS v0.4.9
  * Firefox v5
  * MSIE 8

Why:
---

In short: it's some weird quirk. See the comments below (or the post above)


In `strict mode` `this` is never the global, but also in `strict mode` `eval` operates in a separate context in which `this` *is* always the global.

In non-strict mode `this` is the current context. If there is no current context, it assumes the global. An anonymous function has no context and hence in non-strict mode assumes the global.

Sub Rant:

There's a silly misfeature of JavaScript that 99.9% of the time just confuses people called the 'comma operator'.

    var a = 0, b = 1;
    a = 0, 1;          // 1
    (a = 0), 1;        // 1
    a = (0, 1);        // 1
    a = (42, eval);    // eval
    a('this');         // the global object

为什么不简单地在全局范围内将其用作包装函数的参数，如下所示？

(function (global) {
    'use strict';
    // Code
}(this));

干得好 ：）

var globalObject = (function(){return this;})();

这应该在任何地方都可以工作，例如在另一个闭包内部。

编辑-只是更仔细地阅读您的文章，并了解有关ES5严格模式的部分。谁能进一步阐明这一点？只要我还记得，这就是获取全局对象的一种公认方法。我希望它最终不会被破坏。

编辑2-CMS的答案具有有关ES5严格模式对的处理的更多信息this。

我认为在犀牛，节点，浏览器以及jslint（没有其他解决方法标志）中这几乎可以-这有帮助吗？我想念什么吗？

x = 1;
(function(global){
    "use strict";
    console.log(global.x);
}(this));

虽然我本人倾向于使用window对象，但如果我需要无头测试，则可以使用env.js（犀牛）或Phantom（节点）。

ECMAScript将很快将其添加到其标准中：https : //github.com/tc39/proposal-global

在完成之前，建议这样做：

var getGlobal = function () {
    // the only reliable means to get the global object is
    // `Function('return this')()`
    // However, this causes CSP violations in Chrome apps.
    if (typeof self !== 'undefined') { return self; }
    if (typeof window !== 'undefined') { return window; }
    if (typeof global !== 'undefined') { return global; }
    throw new Error('unable to locate global object');
};

这没有传递jslint： var Fn = Function, global = Fn('return this')();

自己尝试：http : //www.jslint.com/

这将： var Fn = Function, global = new Fn('return this')();

但实际上，根据MDN来说，这些是同一回事：

将Function构造函数作为函数调用（不使用new运算符）与作为构造函数调用它具有相同的效果。

以下解决方案适用于：

• 铬
• 节点JS
• 火狐浏览器
• 微软IE
• 网络工作者

代码是：

(function (__global) {
  // __global here points to the global object
})(typeof window !== "undefined" ? window : 
   typeof WorkerGlobalScope !== "undefined" ? self :
   typeof global !== "undefined" ? global :
   Function("return this;")());

您只需要将X更改为您想要的变量名称即可

我之前遇到过这个问题，我对解决方案不满意，但是它可以正常工作并传递JSLint（假设browser | assume节点）：

"use strict";
var GLOBAL;
try{
    /*BROWSER*/
    GLOBAL = window;
}catch(e){
    /*NODE*/
    GLOBAL = global;
}
if(GLOBAL.GLOBAL !== GLOBAL){
    throw new Error("library cannot find the global object");
}

一旦拥有GLOBAL变量，就可以进行检查，并且在脚本类型的末尾

delete GLOBAL.GLOBAL;

这是我正在使用的：

"use strict";
if(this && this.hasOwnProperty && !this.hasOwnProperty('globalScope')){
    try {
        globalScope = Function('return this')();
    }catch(ex){
        if(this.hasOwnProperty('window')){
            globalScope = window;
        }else{
            throw 'globalScope not found';
        }
    }
}