Instanziieren von Objekten in Typescript, ehren lose Kopplung

Question

Ich bin kein OOP-Experte, und bin (seit dem Lernen über lose Kopplung) kämpfen, um eine Antwort auf die Frage zu finden, auf welche Weise Objekte instanziieren, um eine in Typoskript geschriebene Anwendung zu starten.

Ist es in Ordnung, eine Klasse "Main" zu erstellen, deren einziger Zweck darin besteht, alle in einer Anwendung verwendeten Objekte zu instanziieren, einzurichten und weiterzugeben? Hängt dieser Ansatz, abhängig von den Klassen Foo und Bar, gegen die OOP-Prinzipien? Wenn ja, wie würde der Einstiegspunkt der Anwendung aussehen?

heißt

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-weise, was Sie tun in Ordnung ist, dann ist es ähnlich, wie es in Java ist zum Beispiel (mit Ausnahme der statischen Hauptfunktion).

Mit typoskript/javascript können Sie jedoch etwas anders machen.
Als Ihr Main Klasse soll ein Singleton sein, da ich nur eine Instanz davon haben übernehmen möchten, können Sie es als ein Objekt nur erstellen:

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

Sie auch eine Schnittstelle für sie haben kann wenn Sie wollen Typen zwingen:

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

let main: Main = { 
    ... 
} 

Aber da Sie in einem Modul sind, können Sie einfach:

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

Und dann aussetzen (exp ort) was du willst.

Wenn Sie jedoch diese Main Klasse erweitern möchten, wie verschiedene Implementierungen dafür, dann bleiben Sie bei dem, was Sie jetzt haben.