改变 JavaScript 的全局对象？

Question

有没有办法改变 JavaScript 中的 root 对象？

例如，在浏览器中，root 对象是“window”。所以

X = 5;
console.log(Y);

等同于：

window.X = 5;
console.log(window.Y);

我现在想做的是改变这个 root 对象，所以当我执行以下操作时：

X = 6;

我需要这个的原因：

在Node.js 应用程序中，程序的每个部分都可以访问全局对象。这是一个大问题，因为 Node.js 网络服务器执行的每个脚本都可以向其中添加新变量。它们将一直存在，直到网络服务器重新启动。我想通过更改全局对象来避免这种情况。

更新

我已经测试了以下代码并得到了一个非常有趣的结果。 您对以下代码有何期待？

var X = {A:"a",B:"b"};

with(X){
    A = 5;
    C = 7;
}
for(a in X){
    console.log(a+" is "+X[a]);
}

/* 
Expected Console Output:
A is 5
B is b
C is 7

Real Console Output:
A is 5;
B is b;

*/

有没有办法按我的预期获得输出？

更新

我现在已经用下面的代码测试了模块系统。

//program.js
var t = require("./module.js");
t.Test();

console.log(A);

//module.js
A = 5;
exports.Test = function(){
    console.log("hello world!");
}

输出是：

hello world!
5

这告诉我，module.js 中定义的变量“A”已添加到 program.js 的全局对象中。该模块也不能解决我的问题。

Answer 1

有with语句，但严格模式下不推荐和禁止使用。

最好明确引用保存对象的变量。

针对更新后的问题：

with 将向上搜索作用域链，直到找到具有匹配属性的对象或到达window。在对象上定义新属性是没有好处的。

var X = { A: 5, B: 8, C: 7};
with(X){
    console.log(A, B, C);
}

Answer 2

如果你在谈论变量，JavaScript 有函数作用域。

X = 5;  // global variable

console.log( window.X );  // 5

(function() {
   var X = 6;  // declare a local variable by using the "var" keyword

   console.log( X );  // 6
})();

console.log( window.X );  // 5

否则，您可以创建一个对象，并为其添加属性。

X = 5; 

console.log( window.X );  // 5

var obj = {};

obj.X = 6;

console.log( obj.X ); // 6

console.log( window.X );  // 5

---

编辑：添加另一个可能可以使用的解决方案。

您可以调用匿名函数，但将函数的上下文设置为您的X 对象。那么函数中的this会引用X。

var X = {};
(function(){
    this.A = 5;
    this.B = 8;
    this.C = 7;
}).call(X);
for(a in X){
    console.log(a+" is "+X[a]);
}

.call() 方法（以及.apply() 方法）允许您显式设置 thisArgof a calling context. The first argument you pass will be howthis` 在调用的上下文中定义。

或者只是将X 作为参数传入。

var X = {};
(function(X){
    X.A = 5;
    X.B = 8;
    X.C = 7;
})(X);
for(a in X){
    console.log(a+" is "+X[a]);
}

虽然最简单的是简单地引用它（正如我在上面的回答中指出的那样）。

var X = {};
X.A = 5;
X.B = 8;
X.C = 7;
for(a in X){
    console.log(a+" is "+X[a]);
}

---

或使用 模块 模式：

   /****** I'm guessing at the use of "global" here ********/
global.myNamespace = (function(global,undefined) {

    // define the object to be returned
    var X = {};

    //  define private local variables
    var a_local = 'some value';
    var another_local = 'some other value';

    // define private functions
    function myFunc() {
        // do something with local variables
    }

    // give the return object public members
    X.someProperty = 'some value';
    X.anotherProperty = 'another value';
    X.publicFunc = function() {
        //do something with the local variables
        //    or public properties
    };
    X.anotherFunc = function() {
        //do something with the local variables
        //    or public properties
    };
    // return the object
    return X;

})(global);

console.log(myNamespace);

Answer 3

我在 EcmaScript 6 中找到了调整with(context) { ... } 的方法，这样我们分配的任何新变量都将进入context 对象，而不是全局/window 对象。

感谢这篇文章 Metaprogramming in ES6: Part 3 - Proxies 向我介绍了 ES6 代理功能。

在代理中：

• 我们重写 has 以返回 true，因此我们的上下文似乎具有所有属性，并且当我们设置任何变量时，它都会转到对象。
• 我们重写 get 以从我们的上下文中获取属性，或者如果它不存在，我们从 up 对象（默认为全局 window）获取属性。

我知道with 不受欢迎，但这种技术可以创建可变的可扩展模块，我们可以方便地访问成员作为foo 而不是Module.foo，我不认为它不安全或模棱两可。

function scope(x, up=window) {
    return new Proxy(x, {
        has: (o, k) => true,
        get: (o, k) => k in o ? o[k] : up[k]
    });
}

var Test = {};

with (scope(Test)) {
    x = 1;
    y = 2;
    add_x = function(y) {
        console.log(x + y);
    }
}

Test.add_x(10);

with (scope(Test)) {
    x = 3;
    add_y = function(x) {
        console.log(x + y);
    }
}

Test.add_x(20);

Test.y = 5;

Test.add_y(30);