Создать новый объект из параметра типа в обобщенном классе

Ответ 1

Поскольку скомпилированный 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();

Ответ 2

Чтобы создать новый объект в общем коде, вам нужно обратиться к типу с помощью его функции-конструктора. Поэтому вместо того, чтобы писать это:

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);

Смотрите этот вопрос: Общий вывод типа с аргументом класса

Ответ 3

Вся информация о типе стирается со стороны JavaScript, поэтому вы не можете создавать новые T так же, как и состояния @Sohnee, но я бы предпочел, чтобы этот параметр был введен в конструктор:

class A {
}

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

var test = new B<A>(A);

Ответ 4

export abstract class formBase<T> extends baseClass {

  protected item = {} as T;
}

Его объект сможет принимать любой параметр, однако тип T является только ссылкой на машинописный текст и не может быть создан с помощью конструктора. То есть он не будет создавать никаких объектов класса.

Ответ 5

Я пытался создать экземпляр из базового класса. Ни один из приведенных выше примеров не работал для меня, поскольку им требовался конкретный тип для вызова фабричного метода.

После недолгих исследований этого вопроса и невозможности найти решение в Интернете я обнаружил, что это работает.

 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();

Ответ 6

i использую это: let instance = <T>{}; он вообще работает EDIT 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]);
  }
}

Ответ 7

Не совсем отвечаю на вопрос, но есть хорошая библиотека для таких проблем: 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

Ответ 8

В Typescript я использовал Object для разрешения как для типа "один объект", так и для типа "Массив объекта"

public class A<T>  
{   
   public Data:T = new Object() as T; 
}