Cómo lidiar con dependencias cíclicas en Node.js

He estado trabajando con nodejs últimamente y todavía me estoy familiarizando con el sistema de módulos, así que me disculpo si esta es una pregunta obvia. Quiero un código similar al siguiente a continuación:

a.js (el archivo principal se ejecuta con el nodo)

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;

Mi problema parece ser que no puedo acceder a la instancia de ClassA desde una instancia de ClassB.

¿Existe una forma correcta / mejor de estructurar módulos para lograr lo que quiero? ¿Hay una mejor manera de compartir variables entre módulos?

Si bien node.js sí permite requiredependencias circulares , como ha descubierto, puede ser bastante complicado y probablemente sea mejor reestructurar su código para no necesitarlo. Tal vez cree una tercera clase que use las otras dos para lograr lo que necesita.

Intente establecer propiedades en module.exportslugar de reemplazarlo por completo. Por ejemplo, module.exports.instance = new ClassA()en a.js, module.exports.ClassB = ClassBen b.js. Cuando realiza dependencias de módulos circulares, el módulo requerido obtendrá una referencia a un incompleto module.exportsdel módulo requerido, al que puede agregar otras propiedades más adelante, pero cuando configura todo module.exports, realmente crea un nuevo objeto que el módulo requerido no tiene manera de acceder.

[EDITAR] no es 2015 y la mayoría de las bibliotecas (es decir, express) han realizado actualizaciones con mejores patrones, por lo que las dependencias circulares ya no son necesarias. Recomiendo simplemente no usarlos .

Solo asegúrese de que sus exportaciones necesarias estén definidas antes de requerir un archivo con una dependencia circular.

Esto se romperá:

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

module.exports = ClassA;

Esto funcionará:

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

Uso este patrón todo el tiempo para acceder a express.js appen otros archivos:

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

A veces es realmente artificial introducir una tercera clase (como aconseja JohnnyHK), así que además de Ianzz: si desea reemplazar el module.exports, por ejemplo, si está creando una clase (como el archivo b.js en el ejemplo anterior), esto también es posible, solo asegúrese de que en el archivo que está comenzando la circular requiera, la declaración 'module.exports = ...' ocurre antes de la declaración require.

a.js (el archivo principal se ejecuta con el nodo)

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 solución es 'declarar adelante' su objeto de exportación antes de requerir cualquier otro controlador. Entonces, si estructura todos sus módulos de esta manera y no se encontrará con ningún problema como ese:

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

};

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

// Functions:
var foo = function () {

};

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

Se extiende una solución que requiere un cambio mínimo en module.exportslugar de anularla.

a.js: punto de entrada de la aplicación y módulo que usa el método do de 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: módulo que utiliza el método do 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 
    }
})

Funcionará y producirá:

doing b
doing a

Si bien este código no funcionará:

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

Salida:

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

¿Qué pasa con la pereza que requiere solo cuando lo necesita? Entonces su b.js se ve de la siguiente manera

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

Por supuesto, es una buena práctica poner todas las declaraciones obligatorias en la parte superior del archivo. Pero no son las ocasiones, cuando me perdono para recoger algo fuera de un módulo de otro modo no relacionado. Llámalo hack, pero a veces es mejor que introducir una dependencia adicional, o agregar un módulo adicional o agregar nuevas estructuras (EventEmitter, etc.)

Otro método que he visto hacer es exportar en la primera línea y guardarlo como una variable local como esta:

let self = module.exports = {};

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

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

Tiendo a usar este método, ¿conoces alguna desventaja?

Puede resolver esto fácilmente: simplemente exporte sus datos antes de requerir cualquier otra cosa en los módulos donde usa 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();

Similar a las respuestas de lanzz y setect, he estado usando el siguiente patrón:

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

Las Object.assign()copias de los miembros en el exportsobjeto que ya se ha dado a otros módulos.

La =asignación es lógicamente redundante, ya que solo se está configurando module.exportsa sí misma, pero la estoy usando porque ayuda a mi IDE (WebStorm) a reconocer que firstMemberes una propiedad de este módulo, por lo que "Ir a -> Declaración" (Cmd-B) y otras herramientas funcionarán desde otros archivos.

Este patrón no es muy bonito, por lo que solo lo uso cuando es necesario resolver un problema de dependencia cíclica.

Aquí hay una solución rápida que he encontrado uso completo.

En el archivo 'a.js'

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

En el archivo 'b.js' escriba lo siguiente

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

De esta manera, en la próxima iteración del evento, las clases de bucle se definirán correctamente y esas declaraciones obligatorias funcionarán como se esperaba.

En realidad terminé requiriendo mi dependencia con

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

No es bonita, pero funciona. Es más comprensible y honesto que cambiar b.js (por ejemplo, solo aumentar modules.export), que de lo contrario es perfecto como está.

Una forma de evitarlo es no requerir un archivo en otro, simplemente pasarlo como argumento a una función, lo que sea que necesite en otro archivo. De esta manera, nunca surgirá una dependencia circular.