Comment gérer les dépendances cycliques dans Node.js

J'ai travaillé avec nodejs ces derniers temps et je me suis toujours familiarisé avec le système de modules, alors excuses si c'est une question évidente. Je veux du code à peu près comme ci-dessous:

a.js (le fichier principal exécuté avec node)

var ClassB = require("./b");

var ClassA = function() {
    this.thing = new ClassB();
    this.property = 5;
}

var a = new ClassA();

module.exports = a;

b.js

var a = require("./a");

var ClassB = function() {
}

ClassB.prototype.doSomethingLater() {
    util.log(a.property);
}

module.exports = ClassB;

Mon problème semble être que je ne peux pas accéder à l'instance de ClassA à partir d'une instance de ClassB.

Existe-t-il un moyen correct / meilleur de structurer les modules pour obtenir ce que je veux? Existe-t-il une meilleure façon de partager des variables entre les modules?

Bien que node.js autorise les requiredépendances circulaires , comme vous l'avez trouvé, cela peut être assez compliqué et il vaut probablement mieux restructurer votre code pour ne pas en avoir besoin. Créez peut-être une troisième classe qui utilise les deux autres pour accomplir ce dont vous avez besoin.

Essayez de définir les propriétés au module.exportslieu de les remplacer complètement. Par exemple, module.exports.instance = new ClassA()dans a.js, module.exports.ClassB = ClassBdans b.js. Lorsque vous créez des dépendances de modules circulaires, le module requérant obtiendra une référence à un module.exportsmodule incomplet du module requis, sur lequel vous pouvez ajouter d'autres propriétés ultérieurement, mais lorsque vous définissez l'ensemble module.exports, vous créez en fait un nouvel objet sur lequel le module requérant n'a pas moyen d'accès.

[EDIT] ce n'est pas 2015 et la plupart des bibliothèques (c'est-à-dire express) ont fait des mises à jour avec de meilleurs modèles donc les dépendances circulaires ne sont plus nécessaires. Je recommande simplement de ne pas les utiliser .

Assurez-vous simplement que vos exportations nécessaires sont définies avant de demander un fichier avec une dépendance circulaire.

Cela va casser:

var ClassA = function(){};
var ClassB = require('classB'); //will require ClassA, which has no exports yet

module.exports = ClassA;

Cela fonctionnera:

var ClassA = module.exports = function(){};
var ClassB = require('classB');

J'utilise ce modèle tout le temps pour accéder à express.js appdans d'autres fichiers:

var express = require('express');
var app = module.exports = express();
// load in other dependencies, which can now require this file and use app

Parfois, il est vraiment artificiel d'introduire une troisième classe (comme le conseille JohnnyHK), donc en plus de Ianzz: Si vous voulez remplacer le module.exports, par exemple si vous créez une classe (comme le fichier b.js dans l'exemple ci-dessus), cela est également possible, assurez-vous simplement que dans le fichier qui démarre la circulaire require, l'instruction 'module.exports = ...' arrive avant l'instruction require.

a.js (le fichier principal exécuté avec node)

var ClassB = require("./b");

var ClassA = function() {
    this.thing = new ClassB();
    this.property = 5;
}

var a = new ClassA();

module.exports = a;

b.js

var ClassB = function() {
}

ClassB.prototype.doSomethingLater() {
    util.log(a.property);
}

module.exports = ClassB;

var a = require("./a"); // <------ this is the only necessary change

La solution est de «déclarer en avant» votre objet d'exportations avant de requérir un autre contrôleur. Donc, si vous structurez tous vos modules comme ceci et que vous ne rencontrerez aucun problème de ce genre:

// Module exports forward declaration:
module.exports = {

};

// Controllers:
var other_module = require('./other_module');

// Functions:
var foo = function () {

};

// Module exports injects:
module.exports.foo = foo;

Une solution qui nécessite un changement minimal consiste à étendre module.exportsau lieu de la remplacer.

a.js - point d'entrée d'application et module utilisant la méthode do from b.js *

_ = require('underscore'); //underscore provides extend() for shallow extend
b = require('./b'); //module `a` uses module `b`
_.extend(module.exports, {
    do: function () {
        console.log('doing a');
    }
});
b.do();//call `b.do()` which in turn will circularly call `a.do()`

b.js - module qui utilise la méthode do à partir de a.js

_ = require('underscore');
a = require('./a');

_.extend(module.exports, {
    do: function(){
        console.log('doing b');
        a.do();//Call `b.do()` from `a.do()` when `a` just initalized 
    }
})

Il fonctionnera et produira:

doing b
doing a

Bien que ce code ne fonctionnera pas:

a.js

b = require('./b');
module.exports = {
    do: function () {
        console.log('doing a');
    }
};
b.do();

b.js

a = require('./a');
module.exports = {
    do: function () {
        console.log('doing b');
    }
};
a.do();

Production:

node a.js
b.js:7
a.do();
    ^    
TypeError: a.do is not a function

Qu'en est-il de la paresse exigeant uniquement lorsque vous en avez besoin? Donc votre b.js ressemble à ceci

var ClassB = function() {
}
ClassB.prototype.doSomethingLater() {
    var a = require("./a");    //a.js has finished by now
    util.log(a.property);
}
module.exports = ClassB;

Bien sûr, il est recommandé de placer toutes les instructions require au-dessus du fichier. Mais il y a des occasions où je me pardonne d'avoir choisi quelque chose dans un module autrement sans rapport. Appelez cela un hack, mais parfois c'est mieux que d'introduire une dépendance supplémentaire, ou d'ajouter un module supplémentaire ou d'ajouter de nouvelles structures (EventEmitter, etc.)

Une autre méthode que j'ai vue des gens est d'exporter à la première ligne et de l'enregistrer en tant que variable locale comme celle-ci:

let self = module.exports = {};

const a = require('./a');

// Exporting the necessary functions
self.func = function() { ... }

J'ai tendance à utiliser cette méthode, connaissez-vous ses inconvénients?

Vous pouvez résoudre ce problème facilement: exportez simplement vos données avant de demander quoi que ce soit d'autre dans les modules où vous utilisez module.exports:

classA.js

class ClassA {

    constructor(){
        ClassB.someMethod();
        ClassB.anotherMethod();
    };

    static someMethod () {
        console.log( 'Class A Doing someMethod' );
    };

    static anotherMethod () {
        console.log( 'Class A Doing anotherMethod' );
    };

};

module.exports = ClassA;
var ClassB = require( "./classB.js" );

let classX = new ClassA();

classB.js

class ClassB {

    constructor(){
        ClassA.someMethod();
        ClassA.anotherMethod();
    };

    static someMethod () {
        console.log( 'Class B Doing someMethod' );
    };

    static anotherMethod () {
        console.log( 'Class A Doing anotherMethod' );
    };

};

module.exports = ClassB;
var ClassA = require( "./classA.js" );

let classX = new ClassB();

Semblable aux réponses de lanzz et setect, j'ai utilisé le modèle suivant:

module.exports = Object.assign(module.exports, {
    firstMember: ___,
    secondMember: ___,
});

Les Object.assign()copies des membres dans l' exportsobjet qui a déjà été donné à d' autres modules.

L' =affectation est logiquement redondante, car elle se définit simplement module.exports, mais je l'utilise car elle aide mon IDE (WebStorm) à reconnaître quefirstMember c'est une propriété de ce module, donc "Aller à -> Déclaration" (Cmd-B) et d'autres outils fonctionneront à partir d'autres fichiers.

Ce modèle n'est pas très joli, donc je ne l'utilise que lorsqu'un problème de dépendance cyclique doit être résolu.

Voici une solution de contournement rapide que j'ai trouvée pleinement utilisée.

Dans le fichier 'a.js'

let B;
class A{
  constructor(){
    process.nextTick(()=>{
      B = require('./b')
    })
  } 
}
module.exports = new A();

Sur le fichier 'b.js', écrivez ce qui suit

let A;
class B{
  constructor(){
    process.nextTick(()=>{
      A = require('./a')
    })
  } 
}
module.exports = new B();

De cette façon, lors de la prochaine itération, les classes de la boucle d'événements seront définies correctement et les instructions require fonctionneront comme prévu.

En fait, j'ai fini par exiger ma dépendance avec

 var a = null;
 process.nextTick(()=>a=require("./a")); //Circular reference!

Ce n'est pas beau, mais ça marche. C'est plus compréhensible et honnête que de changer b.js (par exemple en augmentant uniquement les modules.export), qui autrement est parfait tel quel.

Une façon de l'éviter est de ne pas avoir besoin d'un fichier dans un autre, simplement de le transmettre comme argument à une fonction, ce dont vous avez besoin dans un autre fichier. De cette manière, la dépendance circulaire ne se produira jamais.