RequireJS: zagnieżdżone wymagają wywołania

Question

Mam scenariusz, w którym mam zagnieżdżone wywołania require() w celu załadowania różnych modułów.

Czy istnieje sposób, aby upewnić się, że wszystkie wywołania require() i wszystkie jego elementy podrzędne wymagają() wywoływania są w pełni załadowane przed wywołaniem funkcji wywołania zwrotnego?

Czy istnieje sposób na określenie, że wywołania require() są synchroniczne?

function someFunction(callback) { 

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

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

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

    }); 

    callback(); 
}; 

Answer 1

Trzeba wykonać callback w ostatnim require(...) funkcji:

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

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

Co też mógł zrobić, to określić dependencies with the define function.

Przykład:

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); 
} 

Answer 2

Jest na to sposób, aby require rozmowę synchronizację. Zrób to CommonJS styl:

var module = require('modulepath') 

Tak więc, jeśli chcesz NIE potrzebują funciton fabryka w swoim zagnieżdżonych wymagają połączeń, można „sync” require połączeń tamtędy ... Ale skoro ty jesteś out szczęścia.

Styl AMD requre(depsArray, factoryFn) jest dokładnie taki, jak popychanie kodu do równoległego wątku. Nie ma sposobu, aby uczynić go "synchronizowanym", ale możesz użyć "semaforów" do skoordynowania wyniku.

Odpowiedź na twoje pytanie zależy również w dużym stopniu od tego, co zagnieżdżone A i zagnieżdżonego B. Jeśli zależą one od jakiegoś produktu od góry wymaga jak więc absolutnie musi używać „semaforów gwintowanych” i nie można po prostu wcisnąć zagnieżdżone wymagają połączenia w nazwie określenie połączeń:

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() 
    }); 

    }); 

}; 

Innymi słowy, tylko myśleć o require (dependsArray, factoryFn) jako "wątki" i stosuj swoje zrozumienie korzystania z wątków.