是否可以将全局作用域注入到 ES6 又名单例中的实例化类中?

Question

首先，我需要道歉，因为这将包含大量代码，这会使这个问题膨胀。但是我认为这将有助于更好地理解我的问题。

假设我有这个给定MainModule：

'use strict';
/**
* Loads Module from given name.
* @class {LoadModules}
*/
class LoadModules {
constructor(moduleName) {
// define Modulename.
this.moduleName = moduleName;
}
/**
* Initialize module.
* @method init
* @return {void} [nothing]
*/
init() {
// Path Module.
const path = require('path');
// Require Module from given Name.
let ModuleToLoad = require(path.join(__dirname, 'Modules', this.moduleName, this.moduleName + '.js'));
// Instatiate Module.
ModuleToLoad = new ModuleToLoad();
// Start module.
ModuleToLoad.init();
}
}

还有一个可以加载到MainModule中的模块：

/**
* This is a Module which can be loaded by the MainModule.
* @class {ModuleToBeLoaded}
*/
module.exports = class ModuleToBeLoaded {
constructor() {
/**
* Empty
*/
}
/**
* Initialize newly loaded Module.
* @method init
* @return {void} [nothing]
*/
init() {
console.log('module Loaded');
}
};

如您所见，这用于动态加载模块，工作正常。

我的问题是我动态加载其他模块的MainModule无法在模块之间共享自己的全局范围，或者至少我没有弄清楚如何。我很清楚这很复杂，因为我的MainModule和ModuleToBeLoaded在不同的文件中。

例如，我在MainModule的全球范围内有一个LoggerClass：

// This is in the global scope.
const LoggerClass = new Logger();
/**
* LoadModule class stuff comes after this.
*/

我希望所有模块都像在自己的全局范围内一样访问 LoggerClass，而无需在每个模块中一次又一次地定义它。例如，我将ModuleToBeLoaded类中的console.log更改为：

/**
* Initialize newly loaded Module.
* @method init
* @return {void} [nothing]
*/
init() {
LoggerClass.log('module Loaded');
}

所以基本上我在MainModule中定义了全局变量，我想在ModuleToBeLoaded代码中访问这些全局变量。一个可能的解决方案可能是 更改ModuleToBeLaoded中的constructor.喜欢这个：

constructor(LoggerClass) {
// Here I can set LoggerClass internally.
this.LoggerClass = LoggerClass;
}
/**
* Initialize newly loaded Module.
* @method init
* @return {void} [nothing]
*/
init() {
this.LoggerClass.log('module Loaded');
}

这可以让我像这样实例化类：

// Instatiate Module.
ModuleToLoad = new ModuleToLoad(LoggerClass);

这是正确的方法，还是还有其他解决方案更可取？

我想要实现的是 ES6 中已知的模式singelton pattern。 欲了解更多信息，请查看此维基页面：https://en.wikipedia.org/wiki/Singleton_pattern

---

旁注：我处于没有任何第三方库的NodeJS 7.10.0环境中。

问候 美金

Answer 1

LoggerClass.js这就是你制作单例的方式(总是相同的实例)

let instance;
module.exports = function () {
if (!instance) {
instance = new LoggerClass();
}
return instance;
}
class LoggerClass {
constructor() {
this.instanceData = Date.now();
}
log() {
console.log(`logging secret instance: ${this.instanceData}`);
}
}

加载模块.js

const getLoggerClass = require('./LoggerClass');
module.exports = class LoadModules {
constructor(moduleName) {
this.moduleName = moduleName;
}
init() {
const path = require('path');
// changed the require statement, to make it simpler
let ModuleToLoad = require(path.join(__dirname, this.moduleName + '.js'));
ModuleToLoad = new ModuleToLoad(getLoggerClass());
ModuleToLoad.init();
}
}

模块加载.js

module.exports = class ModuleToBeLoaded {
constructor(logger) {
this.logger = logger;
}
init() {
console.log('ModuleToBeLoaded module Loaded');
this.logger.log();
}
};

模块加载2.js

module.exports = class ModuleToBeLoaded {
constructor(logger) {
this.logger = logger;
}
init() {
console.log('ModuleToBeLoaded2 module Loaded');
this.logger.log();
}
};

演示

> node
> const LoadModules = require('./LoadModules');
> var load = new LoadModules('ModuleToLoad');
> var load2 = new LoadModules('ModuleToLoad2');
> load.init();
ModuleToBeLoaded module Loaded
logging secret instance: 1495528699144
> load2.init();
ModuleToBeLoaded2 module Loaded
logging secret instance: 1495528699144

正如你所注意到的，根据LoggerClass的this.instanceData，实例是相同的。

删除了注释以使代码更简洁

Answer 2

我觉得很奇怪，你有一个单独的constructor和init.为什么不在构造函数中进行初始化？

无论如何，似乎正确的方法确实是将"全局"传递给要加载的模块的构造函数或初始化。

如果确实希望它是全局的，可以将其添加到global命名空间。