Javascript RequireJS：嵌套的require调用

我有一个场景，其中嵌套了require（）调用以加载不同的模块

有没有办法确保在调用回调函数之前，所有require（）调用及其子require（）调用都已完全加载

有没有办法指定require（）调用是同步的

function someFunction(callback) {

  //top level require
  require([...], function(...) {

     //nested require
     require([...], function(...) {
     });

     //nested require
     require([...], function(...) {
     });

  });

  callback();
};

---

您需要执行上一个

require（…）

函数中的

回调

：

function someFunction(callback) {
   require(['somemodule'], function(someModule) {
     // do stuff with someModule...

     // execute callback
     callback(); 
   });
}

您还可以指定您的

例如：

define('somemodule', ['somedependency'], function(someDependency) {
   // return somemodule
   return {
     someProperty: someDependency.getProperty();
   };
});

function someFunction(callBack) {
   var someModule = require('somemodule');   
   var foo = someModule.someProperty;

   return callBack(foo);
}

---

有一种方法可以使

require

呼叫同步。让它成为普通的JS风格：

var module = require('modulepath')

因此，如果您想而不是在嵌套的require调用中需要一个工厂函数，您可以通过这种方式“同步”require调用。。。但既然你这么做了，你就不走运了

AMD风格的

requre（depsArray，factoryFn）

就像将代码推入并行线程。没有办法使其“同步”，但可以使用“信号量”来协调结果

您的问题的答案也很大程度上取决于嵌套A和嵌套B使用什么。如果它们依赖于top require中的某个产品，那么您绝对必须使用“线程信号量”，并且不能将嵌套的require调用推送到命名的define调用中：

function someFunction(callback) {

  var resultOfOuterCode = someResultOfCalculations

  //top level require
  require([...], function(...) {

    var resultOfTopRequireCode = someOtherResultOfCalculations

    var semaphore = {
      'count': 2 // represents the number of thread that need to be "done" before 
      , 'callback':callback // this callback is fired.
      , 'checkIfLast': function(){
        this.count -= 1
        if (!this.count) {
          // count is now 0 - time to run our callback
          this.callback()
        }
      }
    }

    //nested require A
    require([...], function(...) {
      // using resultOfTopRequireCode // <-- !!!! this is important part
      ...
      semaphore.checkIfLast()
    });

    //nested require B
    require([...], function(...) {
      // using resultOfTopRequireCode // <-- !!!! this is important part
      semaphore.checkIfLast()
    });

  });

};

函数someFunction（回调）{
var resultOfOuterCode=someResultOfCalculations
//顶级要求
require（[…]，function（…）{
var resultoftoprequiredcode=someOtherResultOfCalculations
变量信号量={
“count”：2//表示在执行之前需要“完成”的线程数
，“callback”：callback//此回调被激发。
，“checkIfLast”：函数（）{
此值为0.count-=1
如果（！this.count）{
//计数现在是0-运行回调的时间
this.callback（）
}
}
}
//嵌套需要一个
require（[…]，function（…）{
//使用ResultToTopRequiredCode//您不应该使用依赖项吗？是的。但是，我们正在尝试将我们的内容分离到单独的文件中。例如，上面的代码在FileA.js中。FileB.js通过回调调用someFunction（）。但是，它的回调依赖于require（）中出现的某些设置问题是require的异步性质意味着回调在require（）中的依赖项设置之前执行。