Built-in utility type Pick 说明

Question

Can someone explain how built-in Pick<Type, Keys> works?

We have:

1. Implementation of Pick.

type Pick<T,K extends keyof T>={  // (1)
    [P in K]:T[P]                 // (2)
}

2. Interface of Todo object

interface Todo {
    title: string
    description: string
    completed: boolean
}

3. Our object

const obj: Pick<Todo,"title">={  // (3)
    title:"Hello",
}

I don't know why we extend K in point #1?
We have the key "title" in point #3 and then "title" extends keyof Todo in point #1.
Therefore in point #2 we have [P in "title"|"description"|"completed"].
In that case we can use [P in keyof T] instead, but it doesn't work of cource.
I need help.

Answer 1

tl;dr [P in K] allows us to define a union of keys ( K ) which may be a reduced subset of the total number of keys in T . Because we constrain K to be extends keyof T , we are also saying that the keys must exist on the source object of type T . This then allows us to use it as an index for T (eg T[P] ) in later parts of the code

In the example above, using Pick<Todo, 'title'>

• [P in K] = 'title'
• [P in keyof T] = 'title' | 'description' | 'completed' 'title' | 'description' | 'completed'

If we didn't have K , we would not be able to provide the "arguments" needed and instead would be forced to perform operations on all of the keys in T

---

type Pick<T, K extends keyof T> = {
  [P in K]: T[P]
}

interface Todo {
  title: string
  description: string
  completed: boolean
}

interface PickedTodo {
  title: string
}
// equivalent to Pick<Todo, 'title'>

• T : This is our source object type (eg Todo ) from which we will be extracting keys (and their value types) that we are interested in
• K extends keyof T : This is the set of keys ( that must be present in the source object type ) we are interested in extracting to and applying to our destination object type (eg PickedTodo ).
  • The beauty of this syntax is that we can specify a list of keys which is a subset of the source object type's keys (ie doesn't expect all keys).
  • These are all valid unions which satisfy K extends keyof Todo
    • 'title'
    • 'title' | 'description'
    • 'description' | 'completed'
    • 'title' | 'description' | 'completed'
    • etc..
• [P in K] : In simple terms this reads as 'For every key ( P ) which exists in the union you provided ( K ), do something'.
  • This is the TypeScript way of enabling us to loop over an objects keys
  • In our example, PickedTodo only has one key title , ie the value of K is the following union: title
  • This is different to keyof Todo ( keyof T ) which would be the union of all keys on Todo , ie: 'title' | 'description' | 'completed' 'title' | 'description' | 'completed'
• T[P] : Using T as a base, extract the type of the value for each of the keys P
  • In our example we have already determined that there is only one key in the union K , which is title . Therefore we only need to perform this mapping operation once and apply to the destination object.
  • Our destination object receives the key title with the associated value of Todo['title'] ( T[P] ) which as we know is string
  • The resulting object is therefore interface PickedTodo { title: string; } interface PickedTodo { title: string; }