Como lidar com dependências cíclicas no Node.js

Eu tenho trabalhado com o nodejs ultimamente e ainda estou familiarizado com o sistema de módulos, então peço desculpas se esta for uma pergunta óbvia. Quero código aproximadamente como o seguinte abaixo:

a.js (o arquivo principal executado com o nó)

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;

Meu problema parece ser que não consigo acessar a instância da ClassA de dentro de uma instância da ClassB.

Existe uma maneira correta / melhor de estruturar os módulos para alcançar o que eu quero? Existe uma maneira melhor de compartilhar variáveis ​​entre módulos?

Embora o node.js permita requiredependências circulares , como você descobriu, pode ser bastante complicado e provavelmente é melhor reestruturar seu código para não precisar dele. Talvez crie uma terceira classe que use as outras duas para realizar o que você precisa.

Tente ativar as propriedades module.exports, em vez de substituí-las completamente. Por exemplo, module.exports.instance = new ClassA()dentro a.js, module.exports.ClassB = ClassBdentro b.js. Quando você cria dependências de módulos circulares, o módulo exigente obtém uma referência incompleta module.exportsdo módulo necessário, no qual você pode adicionar outras propriedades posteriormente, mas quando define o conjunto module.exports, na verdade, cria um novo objeto que o módulo exigente não possui. maneira de acessar.

[EDIT] não é 2015 e a maioria das bibliotecas (ou seja, express) fez atualizações com melhores padrões, de modo que as dependências circulares não são mais necessárias. Eu recomendo simplesmente não usá-los .

Apenas verifique se as exportações necessárias estão definidas antes de você precisar de um arquivo com uma dependência circular.

Isso vai quebrar:

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

module.exports = ClassA;

Isso funcionará:

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

Eu uso esse padrão o tempo todo para acessar o express.js appem outros arquivos:

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

Às vezes, é realmente artificial introduzir uma terceira classe (como JohnnyHK aconselha), portanto, além de Ianzz: Se você deseja substituir o module.exports, por exemplo, se você estiver criando uma classe (como o arquivo b.js em no exemplo acima), isso também é possível, apenas certifique-se de que, no arquivo que está iniciando a requisição circular, a instrução 'module.exports = ...' ocorra antes da declaração de exigência.

a.js (o arquivo principal executado com o nó)

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

A solução é 'declarar adiante' seu objeto de exportação antes de exigir qualquer outro controlador. Portanto, se você estruturar todos os seus módulos como este e não terá problemas assim:

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

};

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

// Functions:
var foo = function () {

};

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

Uma solução que requer alterações mínimas está se estendendo em module.exportsvez de substituí-la.

a.js - ponto de entrada do aplicativo e módulo que usam o método do 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 usa o método do 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á e produzirá:

doing b
doing a

Embora este código não funcione:

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

Resultado:

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

E quanto à preguiça de exigir apenas quando você precisar? Portanto, seu b.js tem a seguinte aparência

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

Obviamente, é uma boa prática colocar todas as instruções de exigência no topo do arquivo. Mas não são ocasiões, onde eu me perdoar por escolher algo fora de um módulo de outro modo não relacionado. Chame isso de hack, mas às vezes isso é melhor do que introduzir uma dependência adicional ou adicionar um módulo extra ou adicionar novas estruturas (EventEmitter, etc)

Um outro método que eu vi as pessoas fazer é exportar na primeira linha e salvá-lo como uma variável local como esta:

let self = module.exports = {};

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

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

Eu costumo usar esse método, você conhece alguma desvantagem dele?

Você pode resolver isso facilmente: basta exportar seus dados antes de precisar de mais alguma coisa nos módulos em que você 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();

Semelhante às respostas de lanzz e setect, tenho usado o seguinte padrão:

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

As Object.assign()cópias são copiadas para o exportsobjeto que já foi fornecido para outros módulos.

A =atribuição é logicamente redundante, pois está apenas se configurando module.exports, mas eu a estou usando porque ajuda meu IDE (WebStorm) a reconhecer que firstMemberé uma propriedade deste módulo, então "Vá para -> Declaração" (Cmd-B) e outras ferramentas funcionarão com outros arquivos.

Esse padrão não é muito bonito; portanto, eu o uso apenas quando um problema de dependência cíclica precisa ser resolvido.

Aqui está uma solução rápida que eu achei totalmente útil.

No arquivo 'a.js'

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

No arquivo 'b.js', escreva o seguinte

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

Dessa maneira, na próxima iteração das classes do loop de eventos, será definido corretamente e as instruções de solicitação funcionarão conforme o esperado.

Na verdade, acabei exigindo minha dependência de

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

Não é bonito, mas funciona. É mais compreensível e honesto do que alterar o b.js (por exemplo, apenas aumentando o modules.export), que de outra forma é perfeito como está.

Uma maneira de evitá-lo é não exigir um arquivo em outro, apenas passá-lo como argumento para uma função do que você precisar em outro arquivo. Dessa maneira, a dependência circular nunca surgirá.