Node.jsで循環依存関係を処理する方法

私は最近nodejsを使用していて、モジュールシステムを理解しているので、これが明らかな質問である場合は謝罪してください。大体以下のようなコードが欲しい：

a.js（ノードで実行されるメインファイル）

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;

私の問題は、ClassBのインスタンス内からClassAのインスタンスにアクセスできないことです。

私が望むものを達成するためにモジュールを構造化する正しい/より良い方法はありますか？モジュール間で変数を共有するより良い方法はありますか？

node.jsは循環require依存関係を許可しますが、ご存知のようにかなり面倒であり、おそらくコードを再構築してそれを必要としない方がよいでしょう。おそらく、他の2つを使用して必要なことを実行する3番目のクラスを作成します。

プロパティをmodule.exports完全に置き換えるのではなく、に設定してみてください。例えば、module.exports.instance = new ClassA()でa.js、module.exports.ClassB = ClassBでb.js。循環モジュールの依存関係を作成すると、必要なモジュールはmodule.exports、必要なモジュールから不完全な参照を取得します。これにより、後で他のプロパティを追加できますが、全体を設定するとmodule.exports、実際には、必要なモジュールにない新しいオブジェクトが作成されますアクセスする方法。

[編集]それは2015年ではなく、ほとんどのライブラリー（つまり、エクスプレス）は、より良いパターンで更新を行ったので、循環依存は必要なくなりました。単に使用しないことをお勧めします。

循環依存関係のあるファイルが必要になる前に、必要なエクスポートが定義されていることを確認してください。

これは壊れます：

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

module.exports = ClassA;

これは動作します：

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

app他のファイルのexpress.js にアクセスするには、常にこのパターンを使用します。

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

Ianzzに加えて、（JohnnyHKが助言するように）3番目のクラスを導入するのが本当に人為的である場合があります。たとえば、module.exportsを置き換えたい場合（たとえば、クラスを作成している場合（上記の例）、これも可能です。循環requireを開始しているファイルで、 'module.exports = ...'ステートメントがrequireステートメントの前にあることを確認してください。

a.js（ノードで実行されるメインファイル）

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

解決策は、他のコントローラーを必要とする前に、エクスポートオブジェクトを「フォワード宣言」することです。したがって、すべてのモジュールをこのように構成し、そのような問題に遭遇しない場合：

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

};

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

// Functions:
var foo = function () {

};

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

最小限の変更を必要とするソリューションは、それmodule.exportsを上書きする代わりに拡張しています。

a.js-b.js *のメソッドdoを使用するアプリのエントリポイントとモジュール

_ = 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-a.jsからのメソッドdoを使用するモジュール

_ = 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 
    }
})

それは動作し、生成されます：

doing b
doing a

このコードは機能しませんが、

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

出力：

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

必要なときだけ怠惰を必要とするのはどうですか？だからあなたのb.jsは次のようになります

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

もちろん、すべてのrequireステートメントをファイルの上に置くことをお勧めします。しかし、そこにある、私はそうでない場合は無関係なモジュールから何かを取り出すために自分を許す場面が。これをハックと呼びますが、依存関係を追加したり、モジュールを追加したり、新しい構造（EventEmitterなど）を追加したりするよりも良い場合があります。

私が他の人に見たもう1つの方法は、最初の行でエクスポートし、次のようにローカル変数として保存することです。

let self = module.exports = {};

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

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

私はこの方法を使う傾向がありますが、それの欠点について知っていますか？

これは簡単に解決できます。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();

lanzzとsetectの回答と同様に、私は次のパターンを使用しています。

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

Object.assign()コピーメンバーexportsすでに他のモジュールに与えられているオブジェクト。

=それだけで設定されているので割り当ては、論理的に冗長であるmodule.exports自分自身に、私はそれを使用しています、それはそれを認識するために私のIDE（WebStorm）を助けるのでfirstMember、このモジュールのプロパティなので、「移動] - >宣言」（CMD-B）他のツールは他のファイルから機能します。

このパターンはあまりきれいではないため、循環依存の問題を解決する必要がある場合にのみ使用します。

これは、私が使いきったことがわかった簡単な回避策です。

ファイル「a.js」

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

ファイル「b.js」に次のように記述します

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

これにより、イベントループクラスの次の反復で正しく定義され、requireステートメントが期待どおりに機能します。

実際、私は私の依存関係を必要としました

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

きれいではありませんが、動作します。それはb.jsを変更するよりも理解しやすく正直です（たとえば、modules.exportを拡張するだけ）。

これを回避する1つの方法は、あるファイルを別のファイルに要求せず、別のファイルで必要なものを関数の引数として渡すことです。このようにして、循環依存は発生しません。