如何在打字稿中键入一个动态加载其自己成员的类

Question

您好，我正在使用typescript 2.1.4，但我遇到了这个问题。

想象一下我有一个看起来像这样的object

interface IObj{
    key1:ISubObj;
}
interface ISubObj{
    exp:RegExp;
    method:(param:string)=>boolean
}
const obj:IObj={
    key1: {
        exp: /someexp/i,
        method: somemethod
    }
}

somemethod 看起来像这样

function somemethod(regexp){
   return function(param){
       return regexp.test(param)
   }
} 

在类型脚本中我创建了一个看起来像这样的类

export class someClass {
 constructor(obj) {
    for (let k in obj) {
        this[k]=obj[k].method(obj[k].exp)
    }
    return this;
 }
}
export const Foo = new someClass(obj);

我遇到的问题是它解析为有效的javascript 但是，使用Foo.key1(param) 返回一个类型error。 key1 在 Foo 上不存在。

我在课堂上使用了implements someInterface，但只有当我使用key1 作为可选时，接口才有效。我宁愿不使用可选语法

interface someInterface {
    key1?:(param:string)=>boolean
}
export class someClass implements someInterface{...}

有没有办法在动态构造的类上创建有效类型？

编辑

更正了 obj 未传递给构造函数的错字

编辑

使用@toskv 回答我稍微改变了我的解决方案以获得我想要的有效的。虽然这可能不是最好的方法

interface IObj{
    key1:ISubObj;
}
interface ISubObj{
    exp:RegExp;
    method:(param:string)=>boolean
}
const obj:IObj={
    key1: {
        exp: /someexp/i,
        method: somemethod
    }
}
export interface ISomeClass{
   key1:(str:string)=>boolean;
}
export type TSomeClass<T> = {
    [P in keyof T]?=T[P]
}
export class someClass {
 constructor(obj) {
    for (let k in obj) {
        this[k]=obj[k].method(obj[k].exp)
    }
    return this;
 }
}
export const Foo:TSomeClass<ISomeClass> = new someClass(obj);

Answer 1

可能有更好的方法来做这件事，但这里有一些开始。

您可以使用 2.1 中添加的 ma​​ppedTypes 来创建基于 IObj 接口的新类型。

interface IObj {
  key1: ISubObj;
}
interface ISubObj {
  exp: RegExp;
  method: (param: string) => boolean
}

type Result = {
  // must be optional so we can initialize it with nothing
  [P in keyof IObj]?: boolean
}

class Mine {
  // it's not really a property of the class but hey it's typed
  public results: Result = {};

  constructor(obj: IObj) {
    for (let k in obj) {
      this.results[k] = obj[k].method(obj[k].exp)
    }
    return this;
  }
}

// autocomplete and everything
new Mine(null).results.key1 

Here 是操场上的一个例子。

您可以在2.1 release notes 中阅读有关映射类型的更多信息。

在这种情况下，类并没有真正的意义。转换数据的函数同样有效。

function testIObj(obj: IObj): Result {
  let results: Result = {};
  for (let k in obj) {
    results[k] = obj[k].method(obj[k].exp)
  }
  return results;
}


testIObj(null).key1;

这使您可以做一些不错的事情，例如轻松处理它们的整个列表。

如果您的 方法 函数将返回不同的类型，那么扩展以适应它们也相对容易。

 type Result = {
      // must be optional so we can initialize it with nothing
      [P in keyof IObj]?: boolean | number
    }

Answer 2

这可以根据@toskv 的回答来工作。除了必须更新两个接口之外，您是否发现了这方面的问题？

interface IObj{
    key1:ISubObj;
}
interface ISubObj{
    exp:RegExp;
    method:(param:string)=>boolean
}
const obj:IObj={
    key1: {
        exp: /someexp/i,
        method: somemethod
    }
}
export interface ISomeClass{
   key1:(str:string)=>boolean;
}
export type TSomeClass<T> = {
    [P in keyof T]?=T[P]
}
export class someClass {
 constructor(obj) {
    for (let k in obj) {
        this[k]=obj[k].method(obj[k].exp)
    }
    return this;
 }
}
export const Foo:TSomeClass<ISomeClass> = new someClass(obj);