Cách xử lý các phụ thuộc theo chu kỳ trong Node.js

Gần đây tôi đã làm việc với nodejs và vẫn nắm bắt được hệ thống mô-đun để xin lỗi nếu đây là một câu hỏi rõ ràng. Tôi muốn mã đại khái như sau:

a.js (tệp chính chạy với nút)

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;

Vấn đề của tôi dường như là tôi không thể truy cập vào thể hiện của ClassA từ bên trong một thể hiện của ClassB.

Có một cách chính xác / tốt hơn để cấu trúc các mô-đun để đạt được những gì tôi muốn? Có cách nào tốt hơn để chia sẻ các biến giữa các mô-đun không?

Mặc dù node.js không cho phép các requirephụ thuộc vòng tròn , như bạn đã thấy nó có thể khá lộn xộn và có lẽ bạn nên cấu trúc lại mã của mình để không cần nó. Có thể tạo một lớp thứ ba sử dụng hai lớp kia để thực hiện những gì bạn cần.

Cố gắng đặt thuộc tính trên module.exports, thay vì thay thế hoàn toàn. Ví dụ, module.exports.instance = new ClassA()trong a.js, module.exports.ClassB = ClassBtrong b.js. Khi bạn tạo phụ thuộc mô-đun tròn, mô-đun yêu cầu sẽ nhận được tham chiếu đến một phần chưa hoàn chỉnh module.exportstừ mô-đun được yêu cầu, bạn có thể thêm các thuộc tính khác sau, nhưng khi bạn đặt toàn bộ module.exports, bạn thực sự tạo một đối tượng mới mà mô-đun yêu cầu không có cách để truy cập.

[EDIT] không phải năm 2015 và hầu hết các thư viện (tức là express) đã thực hiện cập nhật với các mẫu tốt hơn để phụ thuộc vòng tròn không còn cần thiết nữa. Tôi khuyên bạn chỉ nên không sử dụng chúng .

Chỉ cần đảm bảo xuất khẩu cần thiết của bạn được xác định trước khi bạn yêu cầu một tệp có phụ thuộc vòng tròn.

Điều này sẽ phá vỡ:

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

module.exports = ClassA;

Điều này sẽ làm việc:

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

Tôi sử dụng mẫu này mọi lúc để truy cập express.js apptrong các tệp khác:

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

Đôi khi thật là giả tạo khi giới thiệu lớp thứ ba (như JohnnyHK khuyên), vì vậy, ngoài Ianzz: Nếu bạn muốn thay thế module.exports, ví dụ nếu bạn đang tạo một lớp (như tệp b.js trong ví dụ trên), điều này cũng có thể, chỉ cần đảm bảo rằng trong tệp bắt đầu thông tư yêu cầu, câu lệnh 'module.exports = ...' xảy ra trước câu lệnh yêu cầu.

a.js (tệp chính chạy với nút)

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

Giải pháp là 'chuyển tiếp khai báo' đối tượng xuất khẩu của bạn trước khi yêu cầu bất kỳ bộ điều khiển nào khác. Vì vậy, nếu bạn cấu trúc tất cả các mô-đun của mình như thế này và bạn sẽ không gặp phải bất kỳ vấn đề nào như thế:

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

};

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

// Functions:
var foo = function () {

};

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

Một giải pháp đòi hỏi thay đổi tối thiểu là mở rộng module.exportsthay vì ghi đè lên nó.

a.js - điểm nhập ứng dụng và mô-đun sử dụng phương thức làm từ 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ô-đun sử dụng phương thức làm từ 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 
    }
})

Nó sẽ hoạt động và sản xuất:

doing b
doing a

Trong khi mã này sẽ không hoạt động:

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

Đầu ra:

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

Những gì về lười biếng chỉ yêu cầu khi bạn cần? Vì vậy, b.js của bạn trông như sau

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

Tất nhiên, đó là cách thực hành tốt để đặt tất cả các câu lệnh yêu cầu lên trên cùng của tệp. Nhưng có những dịp, tôi tha thứ cho chính mình vì đã chọn thứ gì đó từ một mô-đun không liên quan. Gọi nó là hack, nhưng đôi khi điều này tốt hơn là giới thiệu thêm một phụ thuộc hoặc thêm một mô-đun bổ sung hoặc thêm các cấu trúc mới (EventEuctor, v.v.)

Một phương pháp khác mà tôi thấy mọi người thực hiện là xuất ở dòng đầu tiên và lưu nó dưới dạng một biến cục bộ như thế này:

let self = module.exports = {};

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

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

Tôi có xu hướng sử dụng phương pháp này, bạn có biết về bất kỳ nhược điểm nào của nó không?

Bạn có thể giải quyết vấn đề này một cách dễ dàng: chỉ cần xuất dữ liệu của bạn trước khi bạn yêu cầu bất kỳ thứ gì khác trong các mô-đun nơi bạn sử dụng 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();

Tương tự như câu trả lời của lanzz và setect, tôi đã sử dụng mẫu sau:

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

Các Object.assign()bản sao các thành viên vào exportsđối tượng đã được trao cho các mô-đun khác.

Các =nhiệm vụ là hợp lý không cần thiết, vì nó chỉ được thiết lập module.exportsvới chính nó, nhưng tôi đang sử dụng nó bởi vì nó giúp IDE của tôi (WebStorm) để nhận ra rằng firstMemberlà một tài sản của mô-đun này, vì vậy "Go To -> Tuyên bố" (Cmd-B) và các công cụ khác sẽ làm việc từ các tập tin khác.

Mẫu này không đẹp lắm, vì vậy tôi chỉ sử dụng nó khi cần giải quyết vấn đề phụ thuộc theo chu kỳ.

Đây là một cách giải quyết nhanh mà tôi đã thấy sử dụng đầy đủ.

Trên tệp 'a.js'

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

Trên tệp 'b.js' hãy viết như sau

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

Cách này trong lần lặp tiếp theo của các lớp vòng lặp sự kiện sẽ được xác định chính xác và những câu lệnh yêu cầu sẽ hoạt động như mong đợi.

Trên thực tế tôi đã kết thúc đòi hỏi sự phụ thuộc của tôi với

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

không đẹp, nhưng nó hoạt động. Điều này dễ hiểu và trung thực hơn là thay đổi b.js (ví dụ: chỉ tăng các mô-đun.export), nếu không thì hoàn hảo.

Một cách để tránh nó là không yêu cầu một tệp khác, chỉ chuyển nó làm đối số cho một chức năng mà bạn cần trong một tệp khác. Bằng cách này, sự phụ thuộc tròn sẽ không bao giờ phát sinh.