在 Typescript 中实例化对象，遵循松散耦合

Question

我不是 OOP 专家，并且（自从了解松散耦合以来）正在努力寻找以何种方式将对象实例化到 bootstrap 用 Typescript 编写的应用程序的问题的答案。

是否可以创建一个“Main”class，其唯一目的是实例化、设置和传递应用程序中使用的所有对象？通过依赖 Foo 和 Bar classes，这种方法是否违反了 OOP 原则？如果是这样，应用程序的入口点会是什么样子？

即

import {Foo} from "./foo-class";
import {Bar} from "./bar-class"; 

interface IOptions {
    amountOfFooObjects: number;
}

class Main {
    private fooObjects: Foo[] = [];

    constructor(options: IOptions) {
       this.buildFoo(options);
    }

    private buildFoo(options) {
       for (let i = 0; i < options.length; i++) {
           this.fooObjects.push(new Foo(new Bar()));
       }
    }
}
let main = new Main({ amountOfFooObjects: 10 });

Answer 1

OO-wise 你正在做的事情很好，它类似于 java 例如（除了静态主函数）。

然而，您可以使用 typescript/javascript 做一些不同的事情。
由于你的 Main class 应该是一个单例，我假设你只打算拥有它的一个实例，你可以将它创建为一个对象：

let main = {
    fooObjects: [],
    init: function(options: IOptions) {
        this.buildFoo(options);
    },
    buildFoo: function(options: IOptions) {
        for (let i = 0; i < options.amountOfFooObjects; i++) {
            this.fooObjects.push(new Foo(new Bar()));
        }
    }
};
main.init({ amountOfFooObjects: 10 });

如果你想强制类型，你也可以有一个接口：

interface Main {
    fooObjects: Foo[];
    init: (options: IOptions) => void;
    buildFoo: (options: IOptions) => void;
}

let main: Main = {
    ...
}

但是由于您在模块中，您可以简单地：

let fooObjects: Foo[] = [];
function init(options: IOptions) {
    buildFoo(options);
}

function buildFoo(options: IOptions) {
    for (let i = 0; i < options.amountOfFooObjects; i++) {
        this.fooObjects.push(new Foo(new Bar()));
    }
}

然后公开（导出）您想要的内容。

但是，如果您希望扩展您的 Main class，例如为其提供不同的实现，那么请坚持使用现有的。

在 Typescript 中实例化对象，遵循松散耦合

Instantiating objects in Typescript, honoring loose coupling

javascript

oop

solid-principles

typescript