Typescript：`let result：{[key：T [K]]：T} = {};`不起作用，如何基于泛型键入对象？

Question

I want to type a simple function called keyBy .

What this function do is to convert an array of objects into object based on provided 'key string':

const arr = [{ name: 'Jason', age: 18 }, { name: 'Amy', age: 25 }];

console.log(keyBy(arr, 'name'));

// => { 'Jason': { name: 'Jason', age: 18 }, 'Amy': { name: 'Amy', age: 25 } }

Now, here is a simple correct javascript implementation without typescript.

function keyBy(arr, key) {
  let result = {};

  arr.forEach(obj => {
    result[obj[key]] = obj;
  });

  return result;
}

Right now, below is my typescript version of keyBy (not compiling):

function keyBy<T, K extends keyof T>(arr: T[], key: K): { [key: T[K]]: T } {

  // typescript yells: An index signature parameter type must be 'string' or 'number'.

  let result: { [key: T[K]]: T } = {};

  arr.forEach(item => {
    result[item[key]] = item;
  });

  return result;
}

Here is the screenshot of my VSCode:

How can I type this keyBy function correctly?

Answer 1

In think you can do in some other way too:

export type Omit<A extends object, K extends keyof A> = Pick<A, Exclude<keyof A, K>>

type KeyOf<T extends Array<any>> = { [K: string]: Omit<T[number], 'name'> };

type Result = KeyOf<[{ name: 'a', attr: 42 }, { name: 'b', attr: 42}, {name: 'c', attr: 42}]>

Omit util will return interface without one key, in this case 'name'.

T[number] when T extends Array will return X

And K always be a string because if ordinary object.

playground

Answer 2

To use named key properties, you need in rather than : :

{ [key in K]: T }

You also need to use K , which is a string union type of property names, not T[K] , which is the value of the property.