Erhalten Typ einer Variablen und neue Instanz dieses Typs

Question

Lets sagen, dass ich eine Basisklasse mit einiger Eigenschaft dataitems habe, die Anordnung von DataItem ist:

export class BaseClass{ 
    dataItems:DataItems[]; 
} 

Dann mehrere Klassen Ich habe die Baseclass und ihre dataitems erweitern Eigenschaft ist ein Array einer Klasse, die sich dataitems:

export class BetterClass extends BaseClass{ 
    dataItems:BetterDataItems[]; 
} 

export class BestClass extends BaseClass{ 
    dataItems:BestDataItems[]; 
} 

Jetzt möchte ich eine Methode in Baseclass hinzuzufügen, die dataitems und fügt sie Array erstellt. Wäre es möglich, all dies in BaseClass zu tun? Ich muss eine Instanz von BetterDataItems oder BestDataItems erstellen, abhängig von der verwendeten Klasse.

Im Moment habe ich einfach hinzugefügt:

dataItemType: typeof DataItem; 

Eigenschaft auf Baseclass und in jeder Klasse erweitern Baseclass überschreiben ich diese Variable mit dem richtigen Datenelementtyp:

in BetterClass:

dataItemType: typeof BetterDataItem = BetterDataItem; 

in BestClass:

dataItemType: typeof BestDataItem = BestDataItem; 

Und dann, in Baseclass ich dies tun:

var dataItem = new this.dataItemType(); 

Dies funktioniert gut, aber meine Frage ist - wäre es möglich, auf alle dataItemType Eigentum zu vermeiden, dass? Kann ich einen Array vom Typ dataItems finden und eine neue Instanz erstellen?

Danke!

Answer 1

Typoskript 1.6 Code:

class DataItems { 

} 

class BaseClass { 
    dataItems:DataItems[]; 
    dataItemType: typeof DataItems = DataItems; 
} 

kompiliert:

var DataItems = (function() { 
    function DataItems() { 
    } 
    return DataItems; 
})(); 
var BaseClass = (function() { 
    function BaseClass() { 
     this.dataItemType = DataItems; 
    } 
    return BaseClass; 
})(); 

Und Sie, dass Typinformationen für dataItems Eigenschaft in BaseClass ist verloren zu sehen. So funktioniert der TypeScript-Compiler. It does not support runtime checking. Also antworte auf deine Frage nein.

---

Ihre Abhilfe mit dataItemType: typeof BetterDataItem = BetterDataItem; funktioniert, weil Sie machen das Typoskript Compiler JS Befehl hinzufügen: this.dataItemType = BetterDataItem;, die später verwendet werden können.

Answer 2

Option 1: Sie könnten das Verfahren in jeder Unterklasse außer Kraft setzen ...

export class BaseClass{ 
    dataItems:DataItem[]; 

    create() { 
     this.dataItems.push(new DataItem()); 
    } 
} 

export class BetterClass extends BaseClass{ 
    dataItems:BetterDataItem[]; 

    create() { 
     this.dataItems.push(new BetterDataItem()); 
    } 
} 

export class BestClass extends BaseClass{ 
    dataItems:BestDataItem[]; 

     create() { 
     this.dataItems.push(new BestDataItem()); 
    } 
} 

Option 2: Aber wenn Sie eine generische Basisklasse einführen, können Sie die Notwendigkeit, entfernen Sie die Eigenschaft dataitems auf jedem definieren Klasse und auch verschiedene Instanzen erstellen.

type MyT = typeof DataItem; 

export class GenericBaseClass<T extends DataItem> { 
    dataItems:T[]; 

    constructor(private dataType: MyT) { 

    } 

    create() { 
     this.dataItems.push(<T>new this.dataType()) 
    } 

} 

export class BaseClass extends GenericBaseClass<DataItem> { 
    constructor() { 
     super(DataItem); 
    } 
} 

export class BetterClass extends GenericBaseClass<DataItem> { 
    constructor() { 
     super(BetterDataItem); 
    } 
} 

export class BestClass extends GenericBaseClass<DataItem> { 
    constructor() { 
     super(BestDataItem); 
    } 
}