183

我正在尝试在我的泛型类中创建一个类型参数的新对象。在我的类View中，我有 2 个作为类型参数传递的泛型类型对象列表，但是当我尝试 make 时new TGridView()，TypeScript 说：

找不到符号'TGridView

这是代码：

module AppFW {
    // Represents a view
    export class View<TFormView extends FormView, TGridView extends GridView> {
        // The list of forms 
        public Forms: { [idForm: string]: TFormView; } = {};

        // The list of grids
        public Grids: { [idForm: string]: TGridView; } = {};

        public AddForm(formElement: HTMLFormElement, dataModel: any, submitFunction?: (e: SubmitFormViewEvent) => boolean): FormView {
            var newForm: TFormView = new TFormView(formElement, dataModel, submitFunction);
            this.Forms[formElement.id] = newForm;
            return newForm;
        }

        public AddGrid(element: HTMLDivElement, gridOptions: any): GridView {
            var newGrid: TGridView = new TGridView(element, gridOptions);
            this.Grids[element.id] = newGrid;
            return newGrid;
        }
    }
}

我可以从泛型类型创建对象吗？

4

12 回答 12

178

要在泛型代码中创建新对象，您需要通过其构造函数引用该类型。所以不要写这个：

function activatorNotWorking<T extends IActivatable>(type: T): T {
    return new T(); // compile error could not find symbol T
}

你需要这样写：

function activator<T extends IActivatable>(type: { new(): T ;} ): T {
    return new type();
}

var classA: ClassA = activator(ClassA);

看到这个问题： Generic Type Inference with Class Argument

于 2014-11-02T05:52:36.053 回答
114

因为编译后的 JavaScript 已经删除了所有类型信息，所以不能T用来新建对象。

您可以通过将类型传递给构造函数以非泛型方式执行此操作。

class TestOne {
    hi() {
        alert('Hi');
    }
}

class TestTwo {
    constructor(private testType) {

    }
    getNew() {
        return new this.testType();
    }
}

var test = new TestTwo(TestOne);

var example = test.getNew();
example.hi();

您可以使用泛型扩展此示例以收紧类型：

class TestBase {
    hi() {
        alert('Hi from base');
    }
}

class TestSub extends TestBase {
    hi() {
        alert('Hi from sub');
    }
}

class TestTwo<T extends TestBase> {
    constructor(private testType: new () => T) {
    }

    getNew() : T {
        return new this.testType();
    }
}

//var test = new TestTwo<TestBase>(TestBase);
var test = new TestTwo<TestSub>(TestSub);

var example = test.getNew();
example.hi();
于 2013-06-29T19:16:29.763 回答
44

所有类型信息都在 JavaScript 端被删除，因此你不能像@Sohnee 状态那样新建 T，但我更喜欢将类型参数传递给构造函数：

class A {
}

class B<T> {
    Prop: T;
    constructor(TCreator: { new (): T; }) {
        this.Prop = new TCreator();
    }
}

var test = new B<A>(A);
于 2016-01-18T13:39:26.917 回答
16

我知道晚了，但@TadasPa 的答案可以通过使用稍微调整一下

TCreator: new() => T

代替

TCreator: { new (): T; }

所以结果应该是这样的

class A {
}

class B<T> {
    Prop: T;
    constructor(TCreator: new() => T) {
        this.Prop = new TCreator();
    }
}

var test = new B<A>(A);
于 2019-09-13T21:06:44.480 回答
14 
export abstract class formBase<T> extends baseClass {

  protected item = {} as T;
}

它的对象将能够接收任何参数，但是，类型 T 只是一个打字稿引用，不能通过构造函数创建。也就是说，它不会创建任何类对象。

于 2017-01-16T11:53:43.450 回答
6

我试图从基类中实例化泛型。上述示例都不适合我，因为它们需要具体类型才能调用工厂方法。

在对此进行了一段时间的研究并且无法在线找到解决方案之后，我发现这似乎可行。

 protected activeRow: T = {} as T;

碎片：

 activeRow: T = {} <-- activeRow now equals a new object...

...

 as T; <-- As the type I specified.

全部一起

 export abstract class GridRowEditDialogBase<T extends DataRow> extends DialogBase{ 
      protected activeRow: T = {} as T;
 }

也就是说，如果您需要一个实际实例，您应该使用：

export function getInstance<T extends Object>(type: (new (...args: any[]) => T), ...args: any[]): T {
      return new type(...args);
}


export class Foo {
  bar() {
    console.log("Hello World")
  }
}
getInstance(Foo).bar();

如果你有论据，你可以使用。

export class Foo2 {
  constructor(public arg1: string, public arg2: number) {

  }

  bar() {
    console.log(this.arg1);
    console.log(this.arg2);
  }
}
getInstance(Foo, "Hello World", 2).bar();
于 2017-10-09T22:54:56.690 回答
2

这是我为保留类型信息所做的：

class Helper {
   public static createRaw<T>(TCreator: { new (): T; }, data: any): T
   {
     return Object.assign(new TCreator(), data);
   }
   public static create<T>(TCreator: { new (): T; }, data: T): T
   {
      return this.createRaw(TCreator, data);
   }
}

...

it('create helper', () => {
    class A {
        public data: string;
    }
    class B {
        public data: string;
        public getData(): string {
            return this.data;
        }
    }
    var str = "foobar";

    var a1 = Helper.create<A>(A, {data: str});
    expect(a1 instanceof A).toBeTruthy();
    expect(a1.data).toBe(str);

    var a2 = Helper.create(A, {data: str});
    expect(a2 instanceof A).toBeTruthy();
    expect(a2.data).toBe(str);

    var b1 = Helper.createRaw(B, {data: str});
    expect(b1 instanceof B).toBeTruthy();
    expect(b1.data).toBe(str);
    expect(b1.getData()).toBe(str);

});
于 2019-10-23T08:51:36.197 回答
2

我是按要求添加的，不是因为我认为它直接解决了问题。我的解决方案涉及一个表格组件，用于显示我的 SQL 数据库中的表格：

export class TableComponent<T> {

    public Data: T[] = [];

    public constructor(
        protected type: new (value: Partial<T>) => T
    ) { }

    protected insertRow(value: Partial<T>): void {
        let row: T = new this.type(value);
        this.Data.push(row);
    }
}

为了使用它，假设我的数据库 VW_MyData 中有一个视图（或表），并且我想为查询返回的每个条目点击 VW_MyData 类的构造函数：

export class MyDataComponent extends TableComponent<VW_MyData> {

    public constructor(protected service: DataService) {
        super(VW_MyData);
        this.query();
    }

    protected query(): void {
        this.service.post(...).subscribe((json: VW_MyData[]) => {
            for (let item of json) {
                this.insertRow(item);
            }
        }
    }
}

这比简单地将返回值分配给 Data 更可取的原因是，我有一些代码在其构造函数中将转换应用于 VW_MyData 的某些列：

export class VW_MyData {
    
    public RawColumn: string;
    public TransformedColumn: string;


    public constructor(init?: Partial<VW_MyData>) {
        Object.assign(this, init);
        this.TransformedColumn = this.transform(this.RawColumn);
    }

    protected transform(input: string): string {
        return `Transformation of ${input}!`;
    }
}

这允许我对输入​​到 TypeScript 的所有数据执行转换、验证和其他任何操作。希望它为某人提供一些见解。

于 2020-07-15T00:55:22.337 回答
1

没有完全回答这个问题，但是，有一个很好的库来解决这些问题：https ://github.com/typestack/class-transformer （虽然它不适用于泛型类型，因为它们并不真正存在在运行时（这里所有的工作都是用类名完成的（它们是类的构造函数）））

例如：

import {Type, plainToClass, deserialize} from "class-transformer";

export class Foo
{
    @Type(Bar)
    public nestedClass: Bar;

    public someVar: string;

    public someMethod(): string
    {
        return this.nestedClass.someVar + this.someVar;
    }
}

export class Bar
{
    public someVar: string;
}

const json = '{"someVar": "a", "nestedClass": {"someVar": "B"}}';
const optionA = plainToClass(Foo, JSON.parse(json));
const optionB = deserialize(Foo, json);

optionA.someMethod(); // works
optionB.someMethod(); // works
于 2019-05-11T20:08:20.437 回答
1

我参加聚会迟到了，但这就是我的工作方式。对于数组，我们需要做一些技巧：

   public clone<T>(sourceObj: T): T {
      var cloneObj: T = {} as T;
      for (var key in sourceObj) {
         if (sourceObj[key] instanceof Array) {
            if (sourceObj[key]) {
               // create an empty value first
               let str: string = '{"' + key + '" : ""}';
               Object.assign(cloneObj, JSON.parse(str))
               // update with the real value
               cloneObj[key] = sourceObj[key];
            } else {
               Object.assign(cloneObj, [])
            }
         } else if (typeof sourceObj[key] === "object") {
            cloneObj[key] = this.clone(sourceObj[key]);
         } else {
            if (cloneObj.hasOwnProperty(key)) {
               cloneObj[key] = sourceObj[key];
            } else { // insert the property
               // need create a JSON to use the 'key' as its value
               let str: string = '{"' + key + '" : "' + sourceObj[key] + '"}';
               // insert the new field
               Object.assign(cloneObj, JSON.parse(str))
            }
         }
      }
      return cloneObj;
   }

像这样使用它：

  let newObj: SomeClass = clone<SomeClass>(someClassObj);

它可以改进，但可以满足我的需要！

于 2020-03-31T01:08:11.113 回答
0

我用这个：let instance = <T>{}; 它通常工作编辑1：

export class EntityCollection<T extends { id: number }>{
  mutable: EditableEntity<T>[] = [];
  immutable: T[] = [];
  edit(index: number) {
    this.mutable[index].entity = Object.assign(<T>{}, this.immutable[index]);
  }
}
于 2017-10-03T15:07:57.173 回答
0

如果您在构造函数中需要参数，这是示例：

class Sample {
    public innerField: string;

    constructor(data: Partial<Sample>) {
        this.innerField = data.innerField;
    }
}

export class GenericWithParams<TType> {
    public innerItem: TType;

    constructor(data: Partial<GenericWithParams<TType>>, private typePrototype: new (i: Partial<TType>) => TType) {
        this.innerItem = this.factoryMethodOnModel(data.innerItem);
    }

    private factoryMethodOnModel = (item: Partial<TType>): TType => {
        return new this.typePrototype(item);
    };
}

const instance = new GenericWithParams<Sample>({ innerItem : { innerField: 'test' }}, Sample);
于 2020-09-17T14:43:56.680 回答