Comment gérer les dépendances circulaires avec RequireJS/AMD?

C'est en effet une restriction de l'AMD format. Vous pouvez utiliser les exportations, et que le problème disparaît. - Je trouver les exportations d'être moche, mais c'est la manière dont les CommonJS modules de résoudre le problème:

define("Employee", ["exports", "Company"], function(exports, Company) {
    function Employee(name) {
        this.name = name;
        this.company = new Company.Company(name + "'s own company");
    };
    exports.Employee = Employee;
});
define("Company", ["exports", "Employee"], function(exports, Employee) {
    function Company(name) {
        this.name = name;
        this.employees = [];
    };
    Company.prototype.addEmployee = function(name) {
        var employee = new Employee.Employee(name);
        this.employees.push(employee);
        employee.company = this;
    };
    exports.Company = Company;
});

Sinon, le besoin("Employee") que vous mentionnez dans votre message serait trop de travail.

En général avec les modules dont vous avez besoin pour être plus conscient de dépendances circulaires, AMD ou pas. Même dans la plaine, JavaScript, vous devez être sûr d'utiliser un objet comme le G de l'objet dans votre exemple.

Si vous n'avez pas besoin de vos dépendances être chargé au démarrage (par exemple, lorsque vous êtes extension d'une classe), alors c'est ce que vous pouvez faire: (prises de http://requirejs.org/docs/api.html#circular)

Dans le fichier a.js:

    define( [ 'B' ], function( B ){

        //Just an example
        return B.extend({
            //...
        })

    });

Et dans l'autre fichier b.js:

    define( [ ], function( ){ //Note that A is not listed

        var a;
        require(['A'], function( A ){
            a = new A();
        });

        return function(){
            functionThatDependsOnA: function(){
                //Note that 'a' is not used until here
                a.doStuff();
            }
        };

    });

Dans le cas des OP exemple, c'est comment il allait modifier:

    define("Employee", [], function() {

        var Company;
        require(["Company"], function( C ){
            //Delayed loading
            Company = C;
        });

        return function (name) {
            this.name = name;
            this.company = new Company(name + "'s own company");
        };
    });

    define("Company", ["Employee"], function(Employee) {
        function Company(name) {
            this.name = name;
            this.employees = [];
        };
        Company.prototype.addEmployee = function(name) {
            var employee = new Employee(name);
            this.employees.push(employee);
            employee.company = this;
        };
        return Company;
    });

    define("main", ["Employee", "Company"], function (Employee, Company) {
        var john = new Employee("John");
        var bigCorp = new Company("Big Corp");
        bigCorp.addEmployee("Mary");
    });

Toutes les réponses (sauf https://stackoverflow.com/a/25170248/14731) sont erronées. Même la documentation officielle (en novembre 2014) est erroné.

La seule solution qui a fonctionné pour moi est de déclarer un "gatekeeper" fichier, et de définir une méthode qui repose sur les dépendances circulaires. Voir https://stackoverflow.com/a/26809254/14731 pour un exemple concret.

---

Ici, c'est pourquoi les solutions ci-dessus ne fonctionnera pas.

1. Vous ne pouvez pas:

var a;
require(['A'], function( A ){
     a = new A();
});

et ensuite utiliser a plus tard, car il n'y a aucune garantie que ce bloc de code sera exécuté avant le bloc de code qui utilise a. (Cette solution est trompeuse, car elle fonctionne 90% du temps)

1. Je ne vois aucune raison de croire que exports n'est pas vulnérable à la même condition de course.

la solution à cela est:

//module A

    define(['B'], function(b){

       function A(b){ console.log(b)}

       return new A(b); //OK as is

    });


//module B

    define(['A'], function(a){

         function B(a){}

         return new B(a);  //wait...we can't do this! RequireJS will throw an error if we do this.

    });


//module B, new and improved
    define(function(){

         function B(a){}

       return function(a){   //return a function which won't immediately execute
              return new B(a);
        }

    });

maintenant, nous pouvons utiliser ces modules A et B dans le module C

//module C
    define(['A','B'], function(a,b){

        var c = b(a);  //executes synchronously (no race conditions) in other words, a is definitely defined before being passed to b

    });

Dans mon cas, j'ai résolu le problème de la dépendance circulaire en déplaçant le code de la "simple" objet le plus complexe. Pour moi c'était une collecte et une classe de modèle. Je suppose que dans votre cas, je voudrais ajouter l'Employé parties spécifiques de la Société dans la classe d'Employés.

define("Employee", ["Company"], function(Company) {
    function Employee (name) {
        this.name = name;
        this.company = new Company(name + "'s own company");
    };
    Company.prototype.addEmployee = function(name) {
        var employee = new Employee(name);
        this.employees.push(employee);
        employee.company = this;
    };

    return Employee;
});
define("Company", [], function() {
    function Company(name) {
        this.name = name;
        this.employees = [];
    };
    return Company;
});
define("main", ["Employee", "Company"], function (Employee, Company) {
    var john = new Employee("John");
    var bigCorp = new Company("Big Corp");
    bigCorp.addEmployee("Mary");
});

Très orthodoxe, mais il devrait fonctionner pour les cas simples. Et si vous refactoriser addEmployee de prendre un Employé en tant que paramètre, la dépendance devrait être encore plus évident pour les étrangers.