2013-06-17 14 views
8

Fondamentalmente, l'idea è che il modulo "sub" crea un oggetto, e quell'oggetto dovrebbe essere parte di una libreria di utilità che è il modulo "principale". Tuttavia, il "sub" oggetto dipende sui servizi di "main":Come risolvere la dipendenza circolare in Require.js?

// Main module 
define(['sub'], function(sub) { 
    var utils = { 
     utilityMain: function() { 
      // ... 
     }; 
     // ... 
    }; 

    tools.subModule = sub; 

    return tools; 
}); 

// Sub module 
define(['main'], function(main) { 
    return new (function() { 

     // Singleton object using functions in main module 
     var somestuff = function() { 
      main.utilityMain(); 
      // etc 
     }; 
    })(); 
}); 

Come posso raggiungere questo obiettivo con require.js senza creare un buco nero che avrebbe inghiottire l'intero pianeta?

Grazie mille.

risposta

6

ci sono alcune cose suggerite nel the docs:

b può recuperare a più tardi, dopo i moduli sono stati definiti utilizzando il metodo require() (assicurarsi di specificare richiedono come dipendenza in modo giusto contesto viene utilizzato per guardare in alto a)

esempio:

// Sub module 
define(['require'], function(require) { 
    return new (function() { 

     // Singleton object using functions in main module 
     var somestuff = function() { 
      require('main').utilityMain(); 
      // etc 
     }; 
    })(); 
}); 

o

si potrebbe utilizzare invece exports per creare un oggetto vuoto per il modulo che è immediatamente disponibile per riferimento da altri moduli

es:

// Main module 
define(['sub', 'exports'], function(sub, exports) { 
    exports.utilityMain: function() { 
     // ... 
    }; 

    exports.subModule = sub.sub; 
}); 
// Sub module 
define(['main', 'exports'], function(main, exports) { 
    exports.sub = new (function() { 

     // Singleton object using functions in main module 
     var somestuff = function() { 
      main.utilityMain(); 
      // etc 
     }; 
    })(); 
}); 

e

Le dipendenze circolari sono rare e usuall un segno che potresti voler ripensare al design

+0

"ripensare il design", sono assolutamente d'accordo ma al momento è un po 'troppo stretto per questo. Ho già studiato e analizzato ciò che stai proponendo ... Ho cercato di riprovare l'oggetto 'exports' negli ultimi due giorni, e ora mi stai dicendo che è disponibile * immediatamente *? Ho pensato che 'exports' viene restituito a' define'/'require' solo una volta che la funzione factory riprende l'esecuzione? In un secondo momento, sembra che tu stia suggerendo che 'main' dovrebbe riprendere l'esecuzione solo una volta che 'sub' riprende? – pilau

+0

Lo apprezzerei davvero se riuscissi davvero a stabilire l'ordine in cui queste cose accadono tutte. Penso che sia qui che non riesco a capire come questa soluzione risolva il mio problema. Grazie! – pilau

+1

L'uso di "esportazioni" consente a ciascun modulo di avere un riferimento ad alcuni oggetti invece di "non definito" per ciascun modulo. Non è possibile utilizzare immediatamente _functions_ di entrambi i moduli, ma si può essere sicuri che i riferimenti verranno impostati correttamente in fase di runtime. Pensa a entrambe le definizioni dei moduli che funzionano in parallelo. Entrambi sanno dove cercare _look_ per l'altro modulo, ma nessuno dei due può interagire fino a quando non sono entrambi completi. – freejosh