Supponiamo di avere una classe TypeScript:
export class TypeCreator {
entities: Set<Whatever>
registerEntities(e: Set<Whatever>): Set<Whatever>{
return this.entities = e;
}
}
se registerEntities() dovrebbe essere chiamato una sola volta, dovrei lanciare un errore se lo chiamano due volte, o semplicemente sovrascrivere il valore, o è un odore di codice che può essere gestito in un modo diverso, forse con uno schema meno statico ?
In casi come questo, cerco di essere più preciso nel nominare i metodi.
Disclaimer: questa raccomandazione proviene da uno sfondo Java, quindi non so se si adatta anche al mondo TypeScript:
Puoi rendere il TypeCreator immutabile, eliminando il metodo registerEntities() e introducendo solo un costruttore che accetta le entità al momento della creazione dell'oggetto.
Questo non solo rende impossibile impostare le entità più volte, ma evita anche lo stato dell'oggetto inutile tra la creazione e l'essere popolato con entità: non appena hai un oggetto TypeCreator , è completamente inizializzato e pronto per l'uso .
Un modo per risolvere questo problema è utilizzare una mappa:
export class TypeCreator {
entitiesMap: Map<string,Set<Whatever>>
registerEntities(namespace: string, e: Set<Whatever>): Set<Whatever>{
this.entitiesMap.set(namespace,e);
return e;
}
}
ma ciò richiede che qualcuno fornisca una chiave / spazio dei nomi per recuperare quel valore.
È un metodo che deve anche essere chiamato? Se è così allora suggerisco che il codice e i parametri appartengono al costruttore. I metodi iniziali sono un odore di codice. (Diverso dai metodi di fabbrica che sono statici e restituiscono un'istanza configurata). I costruttori sono forse esattamente ciò che stai cercando: una sezione di codice che viene eseguita una volta e che genera un'istanza configurata pronta per l'uso.
Leggi altre domande sui tag object-oriented design-patterns functional-programming