Node.js 同一模块的多个需求似乎会影响每个后续需求的范围

我创建了以下3个文件：

base.js

var base = {};

base.one = 1;
base.two = 2;
base.three = 3;

base.bar = function(){

  console.log( this.three );

};

a、 js

b、 js

test.js

var test_modules = ['a','b'];

test_modules.forEach( function( module_name ){
  require( './' + module_name ).bar();
});

然后像这样运行test.js：

node ./test.js

它的输出是：

6
6

---

为什么当我在“a.js”中设置模块“base”的属性“three”时，它会影响“b.js”中的对象？

当您

require（）

a模块时，它会被计算一次并缓存，以便同一模块的后续

require（）

s不必从磁盘加载，从而获得相同的导出对象。因此，当您更改导出的属性时，对该模块的所有引用都将看到更新的值。

当您

require（）

一个模块时，它将被计算一次并缓存，以便相同模块的后续

require（）

不必从磁盘加载，从而获得相同的导出对象。因此，当您更改导出的属性时，对该模块的所有引用都将看到更新的值。

您正在为

基本

模块引入

全局

状态

模块

a

变异了

base

，然后也导出了它，这意味着对

base

的任何进一步引用都将有一个更新的值

下面的脚本在

test.js

var testModules = ['b', 'a'];
testModules.forEach(function(module) {
  require('./' + module).bar();
});

var Base = require('./base');
var baseInstance = new Base();
baseInstance.three = 6;
module.exports = baseInstance;

var Base = require('./base');
module.exports = new Base();

现在，当您运行

节点test.js

时，您将看到

3
6

为什么？

因为模块的包含顺序发生了变化

如何解决此问题？

很简单，摆脱全局状态。一种选择是使用这样的原型

var Base = function() {
  this.one = 1;
  this.two = 2;
  this.three = 3;
};
Base.prototype.bar = function() {
  console.log(this.three);
};
module.exports = Base;

然后，在

a.js

var testModules = ['b', 'a'];
testModules.forEach(function(module) {
  require('./' + module).bar();
});

var Base = require('./base');
var baseInstance = new Base();
baseInstance.three = 6;
module.exports = baseInstance;

var Base = require('./base');
module.exports = new Base();

和内部

b.js

var testModules = ['b', 'a'];
testModules.forEach(function(module) {
  require('./' + module).bar();
});

var Base = require('./base');
var baseInstance = new Base();
baseInstance.three = 6;
module.exports = baseInstance;

var Base = require('./base');
module.exports = new Base();

现在，当您运行原始的

test.js

时，输出应该是

6
3

---

您正在为

base

模块引入

global

状态

模块

a

变异了

base

，然后也导出了它，这意味着对

base

的任何进一步引用都将有一个更新的值

下面的脚本在

test.js

var testModules = ['b', 'a'];
testModules.forEach(function(module) {
  require('./' + module).bar();
});

var Base = require('./base');
var baseInstance = new Base();
baseInstance.three = 6;
module.exports = baseInstance;

var Base = require('./base');
module.exports = new Base();

现在，当您运行

节点test.js

时，您将看到

3
6

为什么？

因为模块的包含顺序发生了变化

如何解决此问题？

很简单，摆脱全局状态。一种选择是使用这样的原型

var Base = function() {
  this.one = 1;
  this.two = 2;
  this.three = 3;
};
Base.prototype.bar = function() {
  console.log(this.three);
};
module.exports = Base;

然后，在

a.js

var testModules = ['b', 'a'];
testModules.forEach(function(module) {
  require('./' + module).bar();
});

var Base = require('./base');
var baseInstance = new Base();
baseInstance.three = 6;
module.exports = baseInstance;

var Base = require('./base');
module.exports = new Base();

和内部

b.js

var testModules = ['b', 'a'];
testModules.forEach(function(module) {
  require('./' + module).bar();
});

var Base = require('./base');
var baseInstance = new Base();
baseInstance.three = 6;
module.exports = baseInstance;

var Base = require('./base');
module.exports = new Base();

现在，当您运行原始的

test.js

时，输出应该是

6
3