实例化并使用2个或更多JavaScript ES6类

使用JavaScriptES6，我有几个类，我想将我的应用程序的各种关注点分开。我有一个main.js文件，我希望在其中实例化这些类，然后能够在它们之间引用和调用方法

我的问题是：这样做的最佳/标准方式是什么？我目前的做法如下：

在main.js中，我创建了一个App类，它实例化了两个类

import ClassOne from './ClassOne';
import ClassTwo from './ClassTwo';

export default class App {
    constructor () {
        this.one = new ClassOne(this);
        this.two = new ClassTwo(this);
    }
}
const app = new App();

然后在ClassOne.js中我做了这样的事情

export default class ClassOne {
    constructor (app) {
        this.app = app;
        this.app.two.callMethod();
    }
}

---

它确实有效，但它看起来像个傻瓜吗&有更好的方法吗？

我建议在一级和二级设置一个setter。这样一来，只有ClassOne和ClassTwo相互依赖，而不依赖于App的实例

ClassOne.js

export default class ClassOne {
    setTwo (two) {
        this.two = two;
        this.two.callMethod();
    }
}

export default class ClassTwo {
    setOne (one) {
        this.one = one;
        this.one.callMethod();
    }
}

import ClassOne from './ClassOne';
import ClassTwo from './ClassTwo';

export default class App {
    constructor () {
        this.one = new ClassOne();
        this.two = new ClassTwo();

        this.one.setTwo(this.two);
        this.two.setOne(this.one);
    }
}

const app = new App();

ClassTwo.js

export default class ClassOne {
    setTwo (two) {
        this.two = two;
        this.two.callMethod();
    }
}

export default class ClassTwo {
    setOne (one) {
        this.one = one;
        this.one.callMethod();
    }
}

import ClassOne from './ClassOne';
import ClassTwo from './ClassTwo';

export default class App {
    constructor () {
        this.one = new ClassOne();
        this.two = new ClassTwo();

        this.one.setTwo(this.two);
        this.two.setOne(this.one);
    }
}

const app = new App();

main.js

export default class ClassOne {
    setTwo (two) {
        this.two = two;
        this.two.callMethod();
    }
}

export default class ClassTwo {
    setOne (one) {
        this.one = one;
        this.one.callMethod();
    }
}

import ClassOne from './ClassOne';
import ClassTwo from './ClassTwo';

export default class App {
    constructor () {
        this.one = new ClassOne();
        this.two = new ClassTwo();

        this.one.setTwo(this.two);
        this.two.setOne(this.one);
    }
}

const app = new App();

---

我建议在一班和二班安排一名二传手。这样一来，只有ClassOne和ClassTwo相互依赖，而不依赖于App的实例

ClassOne.js

export default class ClassOne {
    setTwo (two) {
        this.two = two;
        this.two.callMethod();
    }
}

export default class ClassTwo {
    setOne (one) {
        this.one = one;
        this.one.callMethod();
    }
}

import ClassOne from './ClassOne';
import ClassTwo from './ClassTwo';

export default class App {
    constructor () {
        this.one = new ClassOne();
        this.two = new ClassTwo();

        this.one.setTwo(this.two);
        this.two.setOne(this.one);
    }
}

const app = new App();

ClassTwo.js

export default class ClassOne {
    setTwo (two) {
        this.two = two;
        this.two.callMethod();
    }
}

export default class ClassTwo {
    setOne (one) {
        this.one = one;
        this.one.callMethod();
    }
}

import ClassOne from './ClassOne';
import ClassTwo from './ClassTwo';

export default class App {
    constructor () {
        this.one = new ClassOne();
        this.two = new ClassTwo();

        this.one.setTwo(this.two);
        this.two.setOne(this.one);
    }
}

const app = new App();

main.js

export default class ClassOne {
    setTwo (two) {
        this.two = two;
        this.two.callMethod();
    }
}

export default class ClassTwo {
    setOne (one) {
        this.one = one;
        this.one.callMethod();
    }
}

import ClassOne from './ClassOne';
import ClassTwo from './ClassTwo';

export default class App {
    constructor () {
        this.one = new ClassOne();
        this.two = new ClassTwo();

        this.one.setTwo(this.two);
        this.two.setOne(this.one);
    }
}

const app = new App();

---

实际上它不起作用。调用

ClassOne

s构造函数时，

App

实例还没有

App.two

属性。当循环依赖性逐渐上升时，我们需要小心。为了确定“最佳”，必须有一些评估标准。“look stoopid”不是一个真正合适的标准。这不应该真正起作用，因为在您尝试使用它时，

two

还没有实例化。显式依赖注入是一种方法，即将

ClassTwo

的实例传递给

ClassOne

，而不是

App

的实例@deceze如果

ClassTwo

还需要引用

ClassOne

实例呢？是的，将其显式化将有助于发现错误，但循环依赖的标准设计是什么（除了全局声明）？@Bergi循环依赖从定义上讲不能在各自的构造函数中要求彼此，因此从逻辑上讲，首先是非常错误的。您只能将这种依赖关系视为可选的，然后在已经实例化的类上设置它。例如：

this.one.two=this.two。实际上它不起作用。调用
ClassOne
s构造函数时，
App
实例还没有
App.two
属性。当循环依赖性逐渐上升时，我们需要小心。为了确定“最佳”，必须有一些评估标准。“look stoopid”不是一个真正合适的标准。这不应该真正起作用，因为在您尝试使用它时，
two
还没有实例化。显式依赖注入是一种方法，即将
ClassTwo
的实例传递给
ClassOne
，而不是
App
的实例@deceze如果
ClassTwo
还需要引用
ClassOne
实例呢？是的，将其显式化将有助于发现错误，但循环依赖的标准设计是什么（除了全局声明）？@Bergi循环依赖从定义上讲不能在各自的构造函数中要求彼此，因此从逻辑上讲，首先是非常错误的。您只能将这种依赖关系视为可选的，然后在已经实例化的类上设置它。例如：
this.one.two=this.two。