JavaScript ES6 循环需要引用

Question

我已将大量数据移动到由类表示的 UI 上。不同的类都使用 FK 相互映射。我试图将对这些数据类的引用保持为 1，以避免混淆指针，因此我将 FK 保留为相关类上的 Ints，然后在需要时查找它们。最初我没有 Cache 类，但我尝试为 UI 和数据之间的数据创建一个管道，并通过它自己的类汇集所有缓存数据请求(我认为这也有助于循环引用)但没有骰子很遗憾。

我对以下示例进行了沙盒处理，以尝试简化我的问题。我使用静态方法来简化示例。与应用程序不同，沙箱还具有更容易分层的类。该示例可能过于复杂，但我正在尽力说明为什么我(认为我)需要循环引用。这可能是 webpack 的问题，或者可能是我不应该有循环引用的哲学问题，任何反馈都会令人难以置信! (我认为同样的场景也会破坏 node.js)

缓存.js

const Person = require("./Person.js")
const Group = require("./Group.js")

class Cache {
    static set() {
        Person.set([
            { name: "Sean", groupID: 1 },
            { name: "Greg", groupID: 1 }
        ])
        Group.set([ {id: 1, name: "A"} ])
    }

    static getGroupByID(id) {
        return Group.getByID(id)
    }
    static getPeopleInGroup(id) {
        return Person.getInGroup(id)
    }
    static getFirstPerson() {
        return Person.getFirstPerson()
    }
}


module.exports = Cache
/* use closures?
module.exports = {
    set: () => Cache.set()
    getGroupByID: (id) => Cache.getGroupByID(id),
    getPeopleInGroup: (id) => Cache.getPeopleInGroup(id),
    getFirstPerson: () => Cache.getFirstPerson()
}
*/

Person.js

const Cache = require("./Cache.js")

const list = []

class Person {
    static set(people) {
        people.forEach( p => {
            list.push( new Person(p) )
        })
    }
    static getInGroup(id) {
        const ar = []
        list.forEach( p => {
            if (p.data.GroupID == id)
                ar.push(p)
        })
        return ar
    }
    static getFirstPerson() {
        return list[0]
    }
    constructor(data) {
        this.data = data
    }

    sayHello() {
        const group = Cache.getGroupByID(this.data.groupID)
        const groupName = group.data.name
        console.log(`${this.data.name} from ${groupName}`)
    }
}

module.exports = Person

Group.js

const Cache = require("./Cache.js")

const hash = {}
class Group {
    static set(groups) {
        groups.forEach( g => {
            hash[g.ID] = new Group(g)
        })
    }
    static getGroupByID(id) {
        return hash[id]
    }

    constructor(data) {
        this.data = data
    }
    sayPeople() {
        const ppl = Cache.getPeopleInGroup(this.data.ID)
        console.log(`${this.data.name} has ${ppl.join(", ")}`)
    }
}

module.exports = Group

app.js

const Cache = require("./Cache.js")
Cache.set()
let person = Cache.getFirstPerson()
person.sayHello()
let group = Cache.getGroupByID(person.data.groupID)
group.sayPeople()

在这个例子中，第一个错误的引用是:

Class Person { ...
  sayHello() {
    const group = Cache.getGroupByID(this.data.groupID)

(缓存是一个空对象)

Answer 1

因此，cache.js 需要 person.js，然后 person.js 需要 cache.js。这是一个通告要求，它会给出您所看到的问题。

这里的设计问题是 person.js 检查 cache.js 的数据(这似乎是合理的)，但是你在 cache 中创建了方法。 js 需要缓存中特定数据类型的知识。这会造成您的循环依赖。

对这些循环依赖的通常通用回答是找出两个模块需要什么代码并将其分解到它自己的模块中，该模块不依赖于任何东西。

在这种情况下，我不太清楚你会怎么做。相反，问题似乎是因为您在缓存中创建了与缓存完全无关的 getGroupByID() 静态变量，并且正在创建这些循环依赖项。这似乎是核心问题。如果你从 cache.js 中删除它们，那么这将释放 cache.js 来完成它的一般工作，你可以删除两个 require() 语句导致它们的循环依赖。

然后，问题就来了，把这些静力学放在哪里。这些似乎有点设计问题。您显然试图让 person.js 和 group.js 成为彼此一无所知的同行。但是，您拥有并非如此的方法。 person.js 中的 sayHello() 最终调用 group.js 和 中的 sayPeople() group.js 最终调用 person.js。

我建议您需要为包含共享实现的 group.js 和 person.js 创建一个新的通用基类，也许您可​​以将它们放在那里静力学。我不完全理解底层代码试图做什么来确定这是最好的解决方案，但我的想法是让 person.js 依赖于它的基类而不是 person.js依赖于group.js，从而打破循环依赖。