是否有一种干净的方式在TypeScript中创建静态可继承的泛型构造函数？

Question

我正在创建一个'Serializable'抽象类，我可以用一个以json对象作为参数的方法调用来创建子类。我用它来处理下面的代码，但它会导致一个相当笨拙的解决方案。

我当前的代码：

abstract class Serializable { 
    public static deserialize<T>(jsonString: string, ctor: { new(): T}) { 
     const newCtor = new ctor; 
     const jsonObject = JSON.parse(jsonString); 
     for (const propName of Object.keys(jsonObject)) { 
      newCtor[propName] = jsonObject[propName] 
     } 
     return newCtor; 
    } 

    public static deserializeList<T>(jsonString: string, ctor: { new(): T}) { 
     let newCtor = new ctor; 
     const newArray = new Array<typeof newCtor>(); 
     const jsonArray = JSON.parse(jsonString)['staff']; 
     for (const jsonObject of jsonArray) { 
      newCtor = new ctor; 
      for (const propName of Object.keys(jsonObject)) { 
       newCtor[propName] = jsonObject[propName] 
      } 
      newArray.push(newCtor); 
     } 
     return newArray; 
    } 
} 

export class Employee extends Serializable { 
    firstName: string; 
    lastName: string; 
} 

我现在可以创建员工的新实例是这样的：

const testJson = '{"firstName": "Max", "lastName": "Mustermann"}'; 
const testEmployee = Employee.deserialize<Employee>(testJson, Employee); 

理想情况下，我希望能够做到这一点：

const testJson = '{"firstName": "Max", "lastName": "Mustermann"}'; 
const testEmployee = Employee.deserialize(testJson); 

我觉得应该有一种方法，不必在一行中写入“员工”三次，而是取代任何用'输入'这个'已经让我无处可去。 我意识到这可能通过不使构造静态的，而是有两条线来避免：

const testJson = '{"firstName": "Max", "lastName": "Mustermann"}'; 
const testEmployee = new Employee(); 
testEmployee.deserialize(testJson); 

但是，如果有任何清洁的方式在同一行要做到这一点，我将不胜感激一个例子！我不完全理解ctor: { new(): T}论点的作用，所以我对解决方案的无知可能源于此。

Answer 1

呀，你可以这样做：

abstract class Serializable { 
    public static deserialize<T>(this: { new(): T }, jsonString: string): T { 
     const newCtor = new (this as any)(); 
     ... 
    } 
} 

const testEmployee = Employee.deserialize2(testJson); // type of testEmployee is Employee 

注意到出现了铸件的this至any，这是必要的，因为Serializable是抽象的，所以编译器抱怨说，它不能被实例化。
如果你删除了抽象部分，那么你也可以删除这个类型。

而且，没有必要遍历这样的属性，你可以简单地使用Object.assign：

public static deserialize<T>(this: { new(): T }, jsonString: string): T { 
    return Object.assign(new (this as any)(), JSON.parse(jsonString)); 
} 

Answer 2

这是关于类型。

abstract class Serializable { 
    public static deserialize(jsonString: Employee) { 
     const newCtor = new Employee(); 
     const jsonObject = JSON.parse(jsonString); 
     for (const propName of Object.keys(jsonObject)) { 
      newCtor[propName] = jsonObject[propName] 
     } 
     return newCtor; 
    } 

    public static deserializeList(jsonString: Employee) { 
     let newCtor = new Employee(); 
     const newArray: Employee[] = []; 
     const jsonArray = JSON.parse(jsonString)['staff']; 
     for (const jsonObject of jsonArray) { 
      newCtor = new ctor; 
      for (const propName of Object.keys(jsonObject)) { 
       newCtor[propName] = jsonObject[propName] 
      } 
      newArray.push(newCtor); 
     } 
     return newArray; 
    } 
} 

如果你不能重写抽象类，那么你就不得不像你已经做过的那样使用它。