Stare pytanie z najczęściej poprawnymi, ale niezbyt skutecznymi odpowiedziami. Oto co proponuję:
Utwórz klasę podstawową, która zawiera metodę init () i metody rzutowania statycznego (dla pojedynczego obiektu i tablicy). Metody statyczne mogą być wszędzie; wersja z klasą bazową i init () pozwala później na łatwe rozszerzenia.
export class ContentItem {
// parameters: doc - plain JS object, proto - class we want to cast to (subclass of ContentItem)
static castAs<T extends ContentItem>(doc: T, proto: typeof ContentItem): T {
// if we already have the correct class skip the cast
if (doc instanceof proto) { return doc; }
// create a new object (create), and copy over all properties (assign)
const d: T = Object.create(proto.prototype);
Object.assign(d, doc);
// reason to extend the base class - we want to be able to call init() after cast
d.init();
return d;
}
// another method casts an array
static castAllAs<T extends ContentItem>(docs: T[], proto: typeof ContentItem): T[] {
return docs.map(d => ContentItem.castAs(d, proto));
}
init() { }
}
Podobne mechanizmy (z przypisaniem () ) zostały wspomniane w poście @ Adam111p. Po prostu kolejny (bardziej kompletny) sposób na zrobienie tego. @Timothy Perez krytycznie odnosi się do przypisania () , ale imho jest tutaj w pełni odpowiednie.
Zaimplementuj pochodną (prawdziwą) klasę:
import { ContentItem } from './content-item';
export class SubjectArea extends ContentItem {
id: number;
title: string;
areas: SubjectArea[]; // contains embedded objects
depth: number;
// method will be unavailable unless we use cast
lead(): string {
return '. '.repeat(this.depth);
}
// in case we have embedded objects, call cast on them here
init() {
if (this.areas) {
this.areas = ContentItem.castAllAs(this.areas, SubjectArea);
}
}
}
Teraz możemy rzutować obiekt pobrany z usługi:
const area = ContentItem.castAs<SubjectArea>(docFromREST, SubjectArea);
Cała hierarchia obiektów SubjectArea będzie miała poprawną klasę.
Przypadek użycia / przykład; utwórz usługę Angular (abstrakcyjna klasa podstawowa ponownie):
export abstract class BaseService<T extends ContentItem> {
BASE_URL = 'http://host:port/';
protected abstract http: Http;
abstract path: string;
abstract subClass: typeof ContentItem;
cast(source: T): T {
return ContentItem.castAs(source, this.subClass);
}
castAll(source: T[]): T[] {
return ContentItem.castAllAs(source, this.subClass);
}
constructor() { }
get(): Promise<T[]> {
const value = this.http.get(`${this.BASE_URL}${this.path}`)
.toPromise()
.then(response => {
const items: T[] = this.castAll(response.json());
return items;
});
return value;
}
}
Użycie staje się bardzo proste; utwórz usługę obszaru:
@Injectable()
export class SubjectAreaService extends BaseService<SubjectArea> {
path = 'area';
subClass = SubjectArea;
constructor(protected http: Http) { super(); }
}
Metoda get () usługi zwróci obietnicę tablicy już rzutowanej jako obiekty SubjectArea (cała hierarchia)
Powiedzmy, że mamy inną klasę:
export class OtherItem extends ContentItem {...}
Tworzenie usługi, która pobiera dane i rzutuje do odpowiedniej klasy, jest tak proste, jak:
@Injectable()
export class OtherItemService extends BaseService<OtherItem> {
path = 'other';
subClass = OtherItem;
constructor(protected http: Http) { super(); }
}