Fou une solution en ligne:

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

.

.

.

Œuvres

• dans chaque environnement (que j'ai testé)
• en mode strict
• et même dans une portée emboîtée

Mise À Jour 2014-Sept-23

cela peut maintenant échouer si les en-têtes HTTP dans le les derniers navigateurs interdisent explicitement eval.

une solution de rechange serait d'essayer / d'attraper la solution originale car seuls les navigateurs sont connus pour exécuter ce type de sous-ensemble de JavaScript.

var global;

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

""

exemple:

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

}());

testé:

"1519210920 google Chrome" v12
• Node.JS v0.4.9
• Firefox v5
• MSIE 8

pourquoi:

en bref: c'est une bizarrerie. Voir les commentaires ci-dessous (ou le message ci-dessus)

Dans strict mode this n'est jamais le global, mais aussi dans strict mode eval fonctionne dans un autre contexte dans lequel this est toujours le mondial.

non-mode strict this est le contexte actuel. Si il n'y a pas de courant contexte, il suppose le global. Une fonction anonyme n'a pas de contexte et donc en mode non-strict assume le global.

Suivant:

il y a une erreur stupide de JavaScript que 99,9% du temps confond juste les gens appelés les 'opérateurs de virgule'.

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

pourquoi ne pas simplement utiliser ceci dans une portée globale comme param à une fonction d'enrubannage, comme suit?

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

Ici, vous allez :)

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

cela devrait fonctionner de n'importe où, par exemple à l'intérieur d'une autre fermeture.

Edit-il suffit de lire votre post plus attentivement et a vu la partie sur ES5 mode strict. Quelqu'un peut-il faire la lumière sur qui? Cela a été le moyen de l'objet global pour aussi longtemps que je me souvienne... Bien sûr, j'espère qu'on ne va pas se briser.

Edition 2 - CMS réponse a plus d'infos sur ES5 strictmod's treatment of this .

je pense que c'est assez bien dans le rhino, noeud, navigateur et avec jslint (sans drapeaux de contournement supplémentaires) - est-ce que cela aiderait? Ai-je raté quelque chose?

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

bien que j'ai moi-même tendance à utiliser l'objet window et si j'ai besoin de tests sans tête je peux utiliser env.js (rhino) ou Phantom (node).

j'ai déjà eu ce problème, Je ne suis pas satisfait de la solution, mais il fonctionne et passe JSLint (supposer browser|assumer node):

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

une fois que vous avez le Global var vous pouvez faire votre vérification, et à la fin du script tapez

delete GLOBAL.GLOBAL;

ce n'est pas passer jslint: var Fn = Function, global = Fn('return this')();

Essayez vous-même: http://www.jslint.com/

ce sera: var Fn = Function, global = new Fn('return this')();

mais effectivement ce sont la même chose selon MDN :

invoquer le constructeur de fonctions en tant que fonction (sans utiliser le nouvel opérateur) a le même effet que l'invoquer en tant que constructeur.

ECMAScript va bientôt ajouter ceci à son standard: https://github.com/tc39/proposal-global

Jusqu'à ce qu'il soit fait, c'est ce qui est recommandé:

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

voici ce que j'utilise:

"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';
        }
    }
}

cette solution suivante fonctionne en:

• Chrome
• Node.Js
• Firefox
• MSIE
• Travailleurs Sur Le Web

le code est:

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

Vous avez juste besoin de changer X pour le nom de la variable que vous voulez