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

我不是OOP专家，并且（自从学习了松散耦合以来）努力寻找以什么方式实例化对象来引导使用Typescript编写的应用程序的问题的答案。在Typescript中实例化对象，遵守松散耦合

是否可以创建一个“Main”类，其唯一目的是实例化，设置并传递应用程序中使用的所有对象？通过取决于Foo和Bar类，这种方法是否违反了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 });

来源

2016-04-24 Ozrix

OO明智的你在做什么是好的，它类似于它是如何在Java例如（除了静态主函数）。

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

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

然后暴露（EXP ort）你想要什么。然而，如果你想扩展你的这个类，比如为它提供不同的实现，那么坚持你现在拥有的东西。

来源

2016-04-24 23:30:01

感谢您的全面回答 – Ozrix

@Ozrix np，但考虑到这只是我的看法，您可以通过深入研究'javascript设计模式'来了解更多的想法和选项，随时了解更多信息。 –

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

回答

相关问题