Javascript 访问typescript中泛型类型的属性？

将泛型类型强制转换为某些实体（如产品、帖子、Todo、客户等）的任何作品（类型E将是类型脚本类型、类或接口）：

function test<E>(o:E):string {
  return (o as any)['property']
}

功能测试（o:E）：字符串{
申报表（如有）[“财产”]
}

只是想看看是否铸造任何是一般应如何处理

要求提供完整的背景资料。以下是正在实现的整个功能：

/**
 * 
 * @param entities The entities to search
 * @param exclude Keys to exclude from each entity
 * 
 * @return E[] Array of entities with properties containing the search term.
 */
export function search<E extends WithProperty>(query:string='', entities:E[], exclude:string[]=[]) {
  const { isArray } = Array

  query = query.toLowerCase();

  let keys:string[] = []
  if (entities.length > 0) {
    keys = excludeKeys(entities[0], exclude)
  }

  return entities.filter(function (e:E) {
    return keys.some((key)=>{
      const value = (e as any)[key];
      if (isArray(value)) {
        return value.some(v => {
          return new String(v).toLowerCase().includes(query);
        });
      }
      else if (!isArray(value)) {
        return new String(value).toLowerCase().includes(query);
      }
    })
  });
}

/**
* 
*@param entities要搜索的实体
*@param排除要从每个实体中排除的键
* 
*@return E[]属性包含搜索词的实体数组。
*/
导出函数搜索（查询：string=''，实体：E[]，排除：string[]=[]））{
常量{isArray}=数组
query=query.toLowerCase（）；
let键：字符串[]=[]
如果（entities.length>0）{
键=排除键（实体[0]，排除）
}
返回实体.过滤器（函数（e:e）{
返回键。一些（（键）=>{
常量值=（e为任意）[键]；
如果（isArray（值））{
返回值。一些（v=>{
返回新字符串（v）.toLowerCase（）.includes（查询）；
});
}
如果（！isArray（值））{
返回新字符串（值）.toLowerCase（）.includes（查询）；
}
})
});
}

/**
*该方法可用于从实例中排除键
*属于“E”类。
* 
*在搜索对象时，我们可以使用它来排除值。
* 
*@param entity类型为E的实例
*@param eclude要排除的键
* 
*/
导出函数excludeKeys（实体：E，exclude:string[]）{
常量键：字符串[]=Object.keys（实体）；
返回键。过滤器（（键）=>{
返回exclude.indexOf（key）<0；
});
}

如果您知道类型约束有一个名为property的属性，则可以定义一个定义该属性的接口，然后使用一个约束来告诉E扩展它。然后您将可以访问该属性，而无需强制转换它

interface WithProperty{
  property:string;
}

function test<E extends WithProperty>(o:E):string {
  return o.property;  // or o["property"] is valid access.
}

对于excludeKeys来说，代码转换的一部分是不可避免的，因为这是一个漫长的过程

导出函数excludeKey（实体：E，exclude:string[]）{
常量键：字符串[]=Object.keys（实体）；
返回键。过滤器（（键）=>{
返回exclude.indexOf（key）<0；
});
}

---

这是否真的构成了一种威胁？这里的用例是什么？您是否希望

o

在键

“property”

处始终有一个

字符串

值的属性？如果是这样，那么

functiontest（o:E）：string{returno.property}

应该可以工作，但是

functiontest（o:{property:string}）{returno.property}

也可以工作，根本没有泛型。所以我对你的意图感到困惑。祝你好运这就是用例。在typescript ATM中实现搜索：对象o只是泛型类型E的实体（客户、产品等）。。。换句话说，它将是一个类型脚本类或接口或类型实例，IIUC总是有一个字符串作为属性键。我认为

扩展

很优雅，但在这种情况下它看起来不起作用，因为必须使用[]访问属性。附加的代码有错误，与您提出的问题无关。我可能会建议

键

应该是

数组

类型，而不是

字符串[]

，然后从那里开始，因为如果你有

o

类型为

E

的值和

k

类型为

E

的值，那么

o[k]

将编译，而无需将

o

断言为

任何

。但是，如果不就什么是真实的达成一致，我就无法继续下去。希望你能得到你想要的答案！谢谢，这有点优雅-不幸的是，它必须是

（o as any）['property']

。。。换句话说，必须使用

[]

@Ole访问该属性。它还使该属性在不强制转换任何内容的情况下有效。@Ole添加了另一个解决方案。很好！！看起来棒极了。更干净！！Hm-我认为它可能不起作用，因为我正在使用

Object.keys（）

获取对象实例的键，如下所示：`const-keys:string[]=Object.keys（entity）；`。。。这在excludeKeys（）函数中使用。。。我把它包括在示例中`

interface WithProperty{
  property:string;
}

function test<E extends WithProperty>(o:E):string {
  return o.property;  // or o["property"] is valid access.
}

export function search<E>(query:string='', entities:E[], exclude:string[]=[]) {
  const { isArray } = Array
  type EKey = keyof E;
  query = query.toLowerCase();

  let keys : EKey[] = []
  if (entities.length > 0) {
    keys = excludeKeys<E>(entities[0], exclude)
  }

  return entities.filter(function (e:E) {
    return keys.some((key =>{
      const value = e[key];
      if (isArray(value)) {
        return value.some(v => {
          return v.toLowerCase().includes(search);
        });
      }
      else if (!isArray(value)) {
        return new String(value).toLowerCase().includes(query);
      }
    })
  });
 }

export function excludeKeys<E>(entity: E, exclude: string[]) {
 const keys: string[] = Object.keys(entity);
  return <(keyof E)[]>keys.filter((key) => {
    return exclude.indexOf(key) < 0;
   });
}