Javascript T[keyof T]不能用于索引{}

我试图通过alogrithm实现一个高效的组，并尝试将类型放入其中。但我得到了一个错误：

T[keyof T] cannot be used to index {}

这是我的尝试

 static groupBy<T>(xs:T[], key: keyof T) {
        return xs.reduce((rv, x)=> {
            (rv[x[key]] = rv[x[key]] || []).push(x);
            return rv;
        }, {});
    };

staticgroupby（xs:T[]，key:keyof T）{
返回x.reduce（（rv，x）=>{
（rv[x[键]]=rv[x[键]| |[]）。按（x）；
返回rv；
}, {});
};

rv:any

rv将any

class A {
  static groupBy<T>(xs: T[], key: keyof T) {
    return xs.reduce((rv: any, x) => {
      (rv[x[key]] = rv[x[key]] || []).push(x);
      return rv;
    }, {});
  }
}

A类{
静态groupBy（xs:T[]，key:keyof T）{
返回x.reduce（（rv:any，x）=>{
（rv[x[键]]=rv[x[键]| |[]）。按（x）；
返回rv；
}, {});
}
}

如何使用它：

interface Person {
  name: string;
  age: number;
  salary: number;
}
const data: Person[] = [
  {name:"deepak", age: 30, salary: 2000},
  {name:"deepak1", age: 32, salary: 1000},
  {name:"deepak", age: 29, salary: 3000}
]
class A {
  static groupBy<T>(xs: T[], key: keyof T) {
    return xs.reduce((rv: any, x) => {
      (rv[x[key]] = rv[x[key]] || []).push(x);
      return rv;
    }, {});
  }
}
console.log(A.groupBy(data, "name"))

接口人{
名称：字符串；
年龄：人数；
工资：人数；
}
常数数据：人[]=[
{姓名：“迪帕克”，年龄：30岁，工资：2000}，
{姓名：“deepak1”，年龄：32岁，工资：1000}，
{姓名：“迪帕克”，年龄：29岁，工资：3000}
]
甲级{
静态groupBy（xs:T[]，key:keyof T）{
返回x.reduce（（rv:any，x）=>{
（rv[x[键]]=rv[x[键]| |[]）。按（x）；
返回rv；
}, {});
}
}
console.log（A.groupBy（数据，“名称”））

Lodash的定义：

groupBy(
            predicate?: Lodash.ListIterator<T, boolean> | Lodash.DictionaryIterator<T, boolean> | string,
            thisArg?: any,
        ): Lodash.Dictionary<T[]>;
        groupBy<R extends {}>(predicate?: R): Lodash.Dictionary<T[]>;

groupBy(
谓词？：Lodash.ListIterator | Lodash.DictionaryIterator |字符串，
thisArg？：任何，
)：洛达斯字典；
groupBy（谓词？：R）：Lodash.Dictionary；

同步组返回一个对象，对象不能将任何其他元素作为除字符串|号以外的键。否则，您可以遵循更一般的解决方案

interface Any<T> {
  [key: string]: T[];
}
interface SMap<T> {
  [key: string]: T;
}
class A {
  static groupBy<T extends SMap<string>>(xs: T[], key: keyof T) {
    return xs.reduce((rv: Any<T>, x) => {
      if (!rv[x[key]]) {
        rv[x[key]] = [];
      }
      rv[x[key]].push(x);
      return rv;
    }, {});
  }
}

接口任意{
[键：字符串]：T[]；
}
接口SMap{
[键：字符串]：T；
}
甲级{
静态groupBy（xs:T[]，key:keyof T）{
返回x.reduce（（rv:Any，x）=>{
如果（！rv[x[键]）{
rv[x[键]]=[]；
}
rv[x[键]]按下（x）；
返回rv；
}, {});
}
}

如果您不想使用

任何

，则需要正确定义类型以告知reducer可以合并数据

函数groupBy（xs:T[]，key:K）{
返回x.reduce（（rv，x）=>{
（rv[x[key]]=rv[x[key]| |[]）？。按（x）；
返回rv；
}, {});
};
const result=groupBy（[{test:'key'}]，'test'）；
结果.键？.length；//1.

T是一个对象，其中传递的键的类型可以用作键（对于rv）

---

对于reducer-它以一个空对象开始-我们需要说的是，结果将是一个对象，其中键的值是来自xs

{[LK2 in T[K]]？：array}

的实体数组，而不是原始数组的长度。但是，它不使用“任何”或“作为”铸造。它还支持组密钥的任何数据类型，因此未知

export function groupBy<T>(xs: T[], key: keyof T): Map<unknown, T[]> {
  return xs.reduce((rv: Map<unknown, T[]>, entity: T) => {
    const value = entity[key];
    if (rv.has(value)) {
      rv.get(value)?.push(entity)
    } else {
      rv.set(value, [entity]);
    }
    return rv;
  }, new Map());
};

---

它没有正确定义类型

constresult2=A.groupBy（[{test:'key'}]，'test'）
result2.key2.length；//可能，但应该是错误的。
“对象不能将任何其他元素作为键，而字符串|数字”对象可以作为键。我做了一些搜索，我认为第一个示例是正确的方法。即使lodash使用的是
any
。请查收。。更新。
const badgesByTypes = groupBy(currentState.badges, 'type');
for (const [key, values] of badgesByTypes.entries()) {
}