Generics 如何创建Typescript类的泛型类型的新实例？

如何在Typescript中按预期完成以下工作

export class ProxyObject<T> {
    private _dataObject:T;
    constructor(dataObject?:T) {
        if (dataObject) {
            this.dataObject = dataObject;
        } else {
            //create a new instance of the generic <T> here
            this.dataObject = <T> new Object();
        }
    }
    set dataObject(dataObject:T) {
        this._dataObject = dataObject;
    }
    get dataObject():T {
        return this._dataObject;
    }
}

export class ClassA {
   myCoolProperty = "My Cool Property";
}

正如我所期望的那样，MyObject中的dataObject上不存在ClassA属性或函数。例如，我希望dataObject具有MyColProperty

我试图编写一个ProxyObject类，当扩展它的DataObject存储时，它被类型化为泛型

谢谢

newobject（）不会创建

t

的实例。试试这个：

class MyObject extends ProxyObject<ClassA> {
    constructor(dataObject?: ClassA) {
        if (dataObject) {
              super(dataObject);
          } else {
              //create a new instance of the generic <T> here
              super(new ClassA());
          }
    }
}

类MyObject扩展了ProxyObject{
构造函数（数据对象？：ClassA）{
if（数据对象）{
超级（数据对象）；
}否则{
//在此处创建泛型的新实例
超级（新ClassA（））；
}
}
}

对于这个问题，我愿意接受一些更酷的答案，但现在我只添加了一个需要重载的方法来返回泛型的新实例

export class ProxyObject<T> {

    private _dataObject:T;

    constructor(dataObject?:any) {
        if (dataObject) {
            this.dataObject = dataObject;
        } else {
            this.dataObject = this.createEmptyDataObject();
        }
    }

    protected createEmptyDataObject():T {
        throw new Error('You must overload the createEmptyDataObject() method on ProxyObject');
        return null;
    }

    set dataObject(dataObject:T) {
        this._dataObject = dataObject;
    }

    get dataObject():T {
        return this._dataObject;
    }
}

导出类代理对象{
私有数据对象：T；
构造函数（数据对象？：任何）{
if（数据对象）{
this.dataObject=dataObject；
}否则{
this.dataObject=this.createEmptyDataObject（）；
}
}
受保护的createEmptyDataObject（）：T{
抛出新错误（“必须在ProxyObject上重载createEmptyDataObject（）方法”）；
返回null；
}
设置数据对象（数据对象：T）{
这个。_dataObject=dataObject；
}
获取数据对象（）：T{
返回此。\u dataObject；
}
}

例如，这是一个例子：

export class TabularRecord extends ProxyObject<TabularRecordDO> {

    createEmptyDataObject():TabularRecordDO {
        return new TabularRecordDO();
    }

    get record():any {
        return this.dataObject.record;
    }

    set record(record:any) {
        this.dataObject.record = record;
    }
}

导出类表格记录扩展了ProxyObject{
createEmptyDataObject（）：表格记录{
返回新的tablerRecorddo（）；
}
get record（）：任何{
返回this.dataObject.record；
}
设置记录（记录：任意）{
this.dataObject.record=记录；
}
}

由于typescript泛型是使用运行时不存在的类型擦除来实现的，因此您可以将该类作为参数传递给基类构造函数，然后使用它来创建新对象

export class DataObjectBase {
}

export class ProxyObject<T extends DataObjectBase> {
    private _dataObject: T;
    constructor(dataObject?: T, cls?: typeof DataObjectBase) {
        if (dataObject) {
            this.dataObject = dataObject;
        } else {
            //create a new instance of the generic <T> here
            this.dataObject = <T> new cls();
        }
    }
    set dataObject(dataObject: T) {
        this._dataObject = dataObject;
    }
    get dataObject(): T {
        return this._dataObject;
    }
}



export class ClassA {
    myCoolProperty = "My Cool Property";
}


export class MyObject extends ProxyObject<ClassA> {
    public constructor(dataObject?: ClassA) {
        super(dataObject, ClassA);
    }
}

new MyObject();
obj.dataObject.myCoolProperty !== undefined

导出类DataObjectBase{
}
导出类代理对象{
私有数据对象：T；
构造函数（dataObject？：T，cls？：DataObjectBase的类型）{
if（数据对象）{
this.dataObject=dataObject；
}否则{
//在此处创建泛型的新实例
this.dataObject=new cls（）；
}
}
设置数据对象（数据对象：T）{
这个。_dataObject=dataObject；
}
获取数据对象（）：T{
返回此。\u dataObject；
}
}
出口A类{
myCoolProperty=“我的酷属性”；
}
导出类MyObject扩展ProxyObject{
公共构造函数（dataObject？：ClassA）{
super（dataObject，ClassA）；
}
}
新的MyObject（）；
obj.dataObject.mycolproperty！==未定义

这种方法在派生类中仍然需要一些代码，但至少它将所有逻辑都保留在基类中

---

类DataObjectBase是必需的，因为如果我使用typeof对象，ClassA不可能实现对象类的符号（因为在ClassA中没有对象所具有的构造函数）。DataObjectBase是一个只有一个构造函数且没有参数的类，ClassA虽然没有显式地从中派生，但可以实现它。

我猜您需要执行

obj.dataObject（）.mycolproperty

因为生成的javascript可能使您的public get属性成为一个函数实际上并不创建泛型的新实例。调试器将dataObject显示为空对象。很抱歉，最初读取时我的想法是错误的。有一点可能会对您有所帮助：这可能是重复的，只要每次扩展ProxyObject时都需要多一点代码就行了。我发布的解决方案比较简单。很遗憾，没有一种简单的方法可以获得泛型类型的新实例。谢谢

export class TabularRecord extends ProxyObject<TabularRecordDO> {

    createEmptyDataObject():TabularRecordDO {
        return new TabularRecordDO();
    }

    get record():any {
        return this.dataObject.record;
    }

    set record(record:any) {
        this.dataObject.record = record;
    }
}

export class DataObjectBase {
}

export class ProxyObject<T extends DataObjectBase> {
    private _dataObject: T;
    constructor(dataObject?: T, cls?: typeof DataObjectBase) {
        if (dataObject) {
            this.dataObject = dataObject;
        } else {
            //create a new instance of the generic <T> here
            this.dataObject = <T> new cls();
        }
    }
    set dataObject(dataObject: T) {
        this._dataObject = dataObject;
    }
    get dataObject(): T {
        return this._dataObject;
    }
}



export class ClassA {
    myCoolProperty = "My Cool Property";
}


export class MyObject extends ProxyObject<ClassA> {
    public constructor(dataObject?: ClassA) {
        super(dataObject, ClassA);
    }
}

new MyObject();
obj.dataObject.myCoolProperty !== undefined