使用前初始化RequireJS模块
假设我有三个模块和一个主模块，如下所示：
//Module A
define([''], function(){
function initialize(param1, param2){
//initialize stuff
}
//other stuff
return {
initialize: initialize,
//whatever else
};
});
//Module B
define(['ModuleA'], function(ModuleA){
function initialize(param2, param3){
//initialize stuff using ModuleA
}
//other stuff
return {
initialize: initialize,
//whatever else
};
});
//Module C
define(['ModuleB'], function(ModuleB){
function initialize(param4, param5){
//initialize stuff using ModuleB
}
//other stuff
return {
initialize: initialize,
//whatever else
};
});
//main module
require(['ModuleA', 'ModuleB', 'ModuleC'], function(ModuleA, ModuleB, ModuleC){
ModuleA.initialize(arg1, arg2);
ModuleB.initialize(arg3, arg4);
ModuleC.initialize(arg5, arg6);
});这里的问题是主模块中所有初始化调用之间都存在时态耦合。作为程序员，我必须记住必须按照什么顺序初始化模块。如果ModuleB是在ModuleA之前初始化的，那么它基本上将使用未初始化的模块，因为ModuleA尚未初始化。现在，我可以使用依赖注入，在这种注入中，我实际上通过初始化方法中的参数传递ModuleB和ModuleC它们的依赖项，但这将违背需求的目的，即处理依赖关系。我最好使用脚本标记并手动传递依赖项，确保每个脚本是独立的。我很想知道是否有其他解决办法。谢谢!
回答 1
Stack Overflow用户
发布于 2017-04-19 20:19:22
您可以在定义函数中进行模块初始化，并在define([..]中指定它的依赖项：
//Module A
define(['SomeModule'], function(SomeModule){
// initialization of the module
return {
//initializedModuleInterface..
};
});如果您遇到模块之间的循环依赖关系，在接口中您可以从一个模块返回，那么在使用模块提供的功能之前，首先要考虑第二个模块的需要，例如，不需要在define([..]中，而是在模块本身被使用时：require("a").doSomething();。
//Inside b.js:
define(["require", "a"],
function(require, a) {
//"a" in this case will be null if "a" also asked for "b",
//a circular dependency.
return function(title) {
return require("a").doSomething();
}
}
);http://requirejs.org/docs/api.html#circular
初始化参数本身可以是另一个提供配置参数的模块。
编辑1:添加使用需求作为动态模块定义器和加载器
如果需要一种动态依赖注入机制的结构，那么仍然可以使用需求。不过，不确定它是否为其设计：
1。当您手头有必要的配置变量时，然后通过执行动态模块定义。
前任：
angular.module('myModule')
.run(function () {
define('myConf', [], function() {
return {
confA: 1,
confB: 2
};
});
});2 .在依赖于myConf 的模块中，模块照常执行：
// Module: ModuleA
define(['myConf', function(myConf) {
// initialization with myConf values.
console.log(myConf.confA);
return some_interface;
});或
define(function(require) {
var myConf = require('myConf');
console.log(myConf.confA);
// initialization with myConf values.
return some_interface;
});3 .在应用程序的生命周期中，当ModuleA**，** ModuleB**..则需要：**
var moduleReq = 'moduleA';
require([moduleReq], function (moduleA) {
// doSomething with moduleA
});这里的诀窍是具有特定名称的模块的动态定义通过define('myConf', [], function() {..})。它允许您在不需要文件的情况下定义模块，并且可以在应用程序的生命周期内随时动态地定义模块。据我所知，它主要用于需求捆绑解决方案。
编辑2:第二种方法--使用需求模块内部的承诺作为内部依赖管理.
可以使用的另一种方法是在requirejs模块中使用承诺来指定等待的依赖项。
我们可以定义一个模块主构造作为一个承诺，并解决它通过接口init功能，当我们有必要的数据。
1。我们一如既往地将每个模块指定为系统中的一个文件。 2。在confModule 中，我们希望被动态初始化，我们用以下模式构建它：
// confModule
define([], function () {
var resolveMain;
var rejectMain;
var promise = new Promise(resolve, reject) {
resolveMain = resolve;
rejectMain = reject;
}
return {
init: function (confVarA, confVarB) {
try {
var moduleInitialized = {
// some preparation of confModule
confVarA: confVarA,
confVarB: confVarB
};
resolve(moduleInitialized);
}
catch (e) {
rejectMain(e);
}
},
then: function (successFn, errorFn) {
return promise.then(successFn, errorFn);
}
}
});我们解决了承诺构造函数之外。附加链接提供了更多关于该模式的好处和缺陷的信息。
3 .在依赖模块中，我们在不需要init功能的情况下以相同的模式定义它们，并添加等待confModule:的承诺。
// moduleA
define(['confModule'], function (confModule) {
var resolveMain;
var rejectMain;
var promise = confModule.then(function(confModuleData) {
var moduleBInterface = {
// prepare module b
};
return moduleBInterface; // this make the promise return another promise to wait on for moduleBInterface return;
};
return {
then: function (successFn, errorFn) {
return promise.then(successFn, errorFn);
}
}
});4 .在我们的代码中，当我们有我们需要的数据时，我们可以使confModule无效：
define(['confModule', function (confModule) {
// some async get of confData
$.get(url, function (data) {
confModule.init(data.a, data.b);
});
});5.在我们使用moduleA的代码中，我们需要使用它作为承诺：
define(['moduleA'], fucntion (moduleA) {
moduleA.then(function (moduleAInteface) {
// do something with moduleA.
});
});https://stackoverflow.com/questions/43504412
复制相似问题
腾讯云开发者
