RequireJS: nidificato richiede chiamate

Question

Ho uno scenario in cui ho nested require() chiama per caricare diversi moduli.

C'è un modo per assicurarmi che tutte le chiamate require() e tutte le relative richieste del richiedente() vengano caricate completamente prima che venga richiamata la funzione di callback?

C'è un modo per specificare che le chiamate require() sono sincrone?

function someFunction(callback) { 

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

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

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

    }); 

    callback(); 
}; 

Answer 1

È necessario eseguire il callback in ultima funzione require(...):

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

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

Che cosa si potrebbe anche fare è quello di specificare la vostra dependencies with the define function.

Esempio:

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

C'è un modo per rendere require chiamata sincronizzazione. Rendono CommonJS stile:

var module = require('modulepath') 

Quindi, se volete NON bisogno di una fabbrica in funciton le chiamate nidificate richiedono, si potrebbe "sync" il bisogno di chiamate in questo modo ... Ma dal momento che non si è fuori di fortuna.

AMD style requre(depsArray, factoryFn) è esattamente come inserire il codice in un thread parallelo. Non c'è modo di renderlo "sincronizzato" ma puoi usare "semafori" per coordinare il risultato.

La risposta alla tua domanda dipende molto anche da ciò che consuma A nidificato e B annidato. Se essi dipendono da qualche prodotto da cima necessaria in questo modo è assolutamente necessario utilizzare "semafori filettati" e non si può semplicemente spingere le chiamate nidificate richiedere in nome di definire le chiamate:

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

    }); 

}; 

In altre parole, basta pensare a richiedere (dependsArray, factoryFn) come "discussioni" e applica la tua comprensione dell'utilizzo di thread ad esso.