Typescript 某类密钥

Question

I am trying to do something like so, where I want to have a an idKey which is a keyof T but only the properties of type number.

Is this possible?

export const updateList = <T>(
  idKey: keyof T extends number,
  list: T[],
  id: number
) => {
  const listItem = list.find(x => x[idKey] === id)
}

Having extends number is not right as gives an error, leaving it off also gives an error of:

This condition will always return 'false' since the types 'T[keyof T]' and 'number' have no overlap.

Answer 1

If I understood your problem correctly, it is not the idKey itself that needs to be of type number , but rather the type T[keyof T] needs to extend type number. So what you want to do is to restrict the T type to types that can be indexed with number . Something like this should work.

export const updateList = <T extends { [key: number]: any }>(
  idKey: keyof T,
  list: T[],
  id: number
) => {
  const listItem = list.find(x => x[idKey] === id)
}

Playground

Answer 2

The type system isn't strong enough to constrain idKey to keys for which T has a number value, but you can get around this by instead using a generic parameter K for the type of idKey and constraining the list elements to objects that have a number value for that key K .

const updateList = <K extends PropertyKey>(
  idKey: K,
  list: Record<K, number>[],
  id: number
) => {
  const listItem = list.find(x => x[idKey] === id)
  // ..
}

The builtin type PropertyKey is equal to string | number | symbol string | number | symbol string | number | symbol (ie any valid property key type), and Record<K, number> (see docs ) stands for {[P in K]: number} . Basically, the type signature enforces that the list parameter is assignable to an array of singleton objects with an idKey number property, which also allows passing an array of objects with additional properties, as long as idKey has a number value.

Calls to updateList will now only type check correctly:

const list = [{a: 8, b: 'x'}]

updateList('a', list, 0)

updateList('b', list, 0) // Error

Note that since the key parameter is leading the type inference, the error will be on the list parameter rather than on 'b' , but that shouldn't be a problem.

TypeScript playground