Cara menangani dependensi siklik di Node.js

Saya telah bekerja dengan nodejs akhir-akhir ini dan masih memahami sistem modul jadi minta maaf jika ini adalah pertanyaan yang jelas. Saya ingin kode kira-kira seperti berikut ini:

a.js (file utama dijalankan dengan 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;

Masalah saya sepertinya saya tidak bisa mengakses instance dari ClassA dari instance ClassB.

Apakah ada cara yang benar / lebih baik untuk menyusun modul untuk mencapai apa yang saya inginkan? Apakah ada cara yang lebih baik untuk berbagi variabel antar modul?

Meskipun node.js memungkinkan requiredependensi melingkar , seperti yang Anda temukan itu bisa sangat berantakan dan Anda mungkin lebih baik merestrukturisasi kode Anda untuk tidak membutuhkannya. Mungkin membuat kelas ketiga yang menggunakan dua lainnya untuk mencapai apa yang Anda butuhkan.

Cobalah untuk mengaktifkan properti module.exports, alih-alih menggantinya sepenuhnya. Misalnya, module.exports.instance = new ClassA()dalam a.js, module.exports.ClassB = ClassBdalam b.js. Ketika Anda membuat dependensi modul melingkar, modul yang membutuhkan akan mendapatkan referensi ke yang tidak lengkap module.exportsdari modul yang diperlukan, yang Anda dapat menambahkan properti lain yang terakhir, tetapi ketika Anda mengatur keseluruhan module.exports, Anda benar-benar membuat objek baru yang modul yang membutuhkan tidak memiliki cara mengakses.

[EDIT] ini bukan tahun 2015 dan sebagian besar perpustakaan (yaitu express) telah membuat pembaruan dengan pola yang lebih baik sehingga dependensi melingkar tidak lagi diperlukan. Saya sarankan tidak menggunakannya .

Pastikan ekspor yang diperlukan sudah ditentukan sebelumnya Anda memerlukan file dengan ketergantungan melingkar.

Ini akan merusak:

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

module.exports = ClassA;

Ini akan berhasil:

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

Saya menggunakan pola ini setiap saat untuk mengakses express.js appdi file lain:

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

Kadang-kadang sangat buatan untuk memperkenalkan kelas ketiga (seperti yang disarankan JohnnyHK), jadi selain Ianzz: Jika Anda ingin mengganti module.exports, misalnya jika Anda membuat kelas (seperti file b.js di contoh di atas), ini dimungkinkan juga, hanya pastikan bahwa dalam file yang memulai lingkaran memerlukan, pernyataan 'module.exports = ...' terjadi sebelum pernyataan memerlukan.

a.js (file utama dijalankan dengan 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

Solusinya adalah 'meneruskan menyatakan' objek ekspor Anda sebelum memerlukan pengontrol lain. Jadi jika Anda menyusun semua modul Anda seperti ini dan Anda tidak akan mengalami masalah seperti itu:

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

};

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

// Functions:
var foo = function () {

};

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

Solusi yang membutuhkan perubahan minimal adalah memperluas module.exportsalih-alih menimpanya.

a.js - titik masuk aplikasi dan modul yang menggunakan metode lakukan dari 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 - modul yang menggunakan metode do dari 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 
    }
})

Ini akan bekerja dan menghasilkan:

doing b
doing a

Sementara kode ini tidak akan berfungsi:

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

Keluaran:

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

Bagaimana dengan malas yang hanya membutuhkan saat Anda perlu? Jadi b.js Anda terlihat sebagai berikut

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

Tentu saja merupakan praktik yang baik untuk meletakkan semua pernyataan yang diperlukan di atas file. Tetapi ada beberapa kesempatan, di mana saya memaafkan diri sendiri karena memilih sesuatu dari modul yang tidak berhubungan. Sebut saja hack, tetapi kadang-kadang ini lebih baik daripada memperkenalkan dependensi lebih lanjut, atau menambahkan modul tambahan atau menambahkan struktur baru (EventEmitter, dll)

Metode lain yang saya lihat orang lakukan adalah mengekspor di baris pertama dan menyimpannya sebagai variabel lokal seperti ini:

let self = module.exports = {};

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

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

Saya cenderung menggunakan metode ini, apakah Anda tahu tentang kelemahannya?

Anda dapat menyelesaikan ini dengan mudah: cukup ekspor data Anda sebelum Anda membutuhkan hal lain dalam modul tempat Anda menggunakan 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();

Mirip dengan jawaban lanzz dan setect, saya telah menggunakan pola berikut:

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

Para Object.assign()salinan anggota keexports objek yang telah diberikan kepada modul lain.

The =tugas secara logis berlebihan, karena itu hanya menetapkan module.exportsuntuk dirinya sendiri, tapi saya menggunakannya karena membantu IDE saya (WebStorm) untuk mengakui bahwafirstMember adalah properti dari modul ini, sehingga "Go To -> Deklarasi" (Cmd-B) dan perkakas lain akan bekerja dari file lain.

Pola ini tidak terlalu cantik, jadi saya hanya menggunakannya ketika masalah ketergantungan siklik perlu diselesaikan.

Ini adalah solusi cepat yang menurut saya cukup bermanfaat.

Di file 'a.js'

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

Pada file 'b.js' tulis yang berikut ini

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

Dengan cara ini pada iterasi berikutnya dari kelas-kelas loop peristiwa akan didefinisikan dengan benar dan pernyataan-pernyataan yang membutuhkan akan bekerja seperti yang diharapkan.

Sebenarnya saya akhirnya membutuhkan ketergantungan dengan

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

tidak cantik, tapi berhasil. Ini lebih dimengerti dan jujur ​​daripada mengubah b.js (misalnya hanya menambah modules.export), yang sebaliknya sempurna seperti apa adanya.

Salah satu cara untuk menghindarinya adalah dengan tidak memerlukan satu file di lain hanya meneruskannya sebagai argumen ke fungsi apa pun yang Anda butuhkan di file lain. Dengan cara ini ketergantungan sirkular tidak akan pernah muncul.