type MyPick<T, K extends keyof T> = {
  [k in K]: T[k]
}

Solution by ivan-abdulin #37356

// 你的答案

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

Solution by lmmzss-jk #37349

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

Solution by minseonkkim #37339

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

Solution by Nakamura25257 #37255

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

1. 泛型 K 是一个联合类型，是 T 的 key 值，通过 keyof 返回所有 key 组成的联合类型
2. extends 泛型约束，使 K 满足条件
3. 使用 in 遍历联合类型的成员作为key（[P: string/number/symbol] 不能跟泛型类型）

Solution by djdidi #37116

type MyPick<T, K extends keyof T> = { [Property in K]: T[Property] }

Solution by dqks #37089

type MyPick<O extends object, K extends keyof O> = { [P in K]: O[P] };

Notes:

• extends (in a generic constraint): restricts the type parameter to types that are assignable to the type after extends.
• keyof: returns the union of all keys of the given object type; K must be one or more keys of O.
• [P in K]: a mapped type that iterates over all keys in K.
• O[P]: an index access type that gets the property type for key P from O.

Solution by Dessouki98 #37050

type MyPick<T, K extends keyof T> = {
  [Key in K]: T[Key]
}

Solution by Dev205Mg #37045

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

Solution by 359Steve #37010

// your answers

Solution by shuhrat-rizaev04 #36995

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

Solution by mag123c #36990

// 你的答案

type MyPick<T, K extends keyof T> = { [key in K] : T[key] }

Solution by songzhelei1109 #36984

// your answers

Solution by matmon12 #36980

// 你的答案
type MyPick<T, K extends keyof T> = {
  [P in K]:T[P]
}

Solution by viulu5824 #36979

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

Solution by YiShengYouNi #36969

// your answers
type MyPick<T, K extends keyof T> = {
  [key in K]:T[key]
}

Solution by Anonymous961 #36958

解题思路

要想实现从类型 T 中选出符合 K 的属性，就需要遍历T，在T中找出K对应的属性，并返回一个新类型

也就是说，如何实现遍历是关键，主要使用 in 和 keyof 这两个关键字，遍历方法如下

type Copy<T> = {
  [P in keyof T]: T[P];
};

type Case = Copy<{
  a: string;
  b: number;
}>;

let obj: Case = {
  a: "1",
  b: 1,
};

另外，还需要注意下错误的测试用例MyPick<Todo, "title" | "completed" | "invalid">，我们必须限制K对应的这一系列属性在T中存在

题解

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

心得与知识点

1. in 和 keyof的使用 来实现遍历
2. 需要注意错误的的测试用例

Solution by lkwavestian #36943

// 你的答案

type MyPick<T, U extends keyof T> = { [P in U]: T[P]; };

Solution by rzy12345 #36925

// your answers
type MyPick<T, K extends keyof T> = {
  [Key in K]: T[Key];
}

Solution by AlexBraunMagic #36921

type MyPick<T extends Record<any,any>, K extends keyof T> = {
  [key in K]: T[key]
}

Solution by tobi-ademola #36883

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

Solution by shaishab316 #36837

type MyPick<T, K extends keyof T> = {
    [P in K]: T[P]
}    //Here we need change from any to this, because we create a new type containing only those fields from T that are specified in K, preserving their types.

import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<Expected1, MyPick<Todo, 'title'>>>,
  Expect<Equal<Expected2, MyPick<Todo, 'title' | 'completed'>>>,
  // @ts-expect-error
  MyPick<Todo, 'title' | 'completed' | 'invalid'>,
]

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

interface Expected1 {
  title: string
}

interface Expected2 {
  title: string
  completed: boolean
}

Solution by GormanProg123 #36812

type MyPick<T, K extends keyof T> = {
  [Key in K]: T[Key];
}

Solution by BernTheSeal #36807

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

/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<Expected1, MyPick<Todo, 'title'>>>,
  Expect<Equal<Expected2, MyPick<Todo, 'title' | 'completed'>>>,
  // @ts-expect-error
  MyPick<Todo, 'title' | 'completed' | 'invalid'>,
]

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

interface Expected1 {
  title: string
}

interface Expected2 {
  title: string
  completed: boolean
}

Solution by AnastasiaSv #36758

type MyPick<T, K extends keyof T> = {
  [P ]: T[P]
};

Solution by seroak #36739

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

Solution by seroak #36738

// your answers
```type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};

Solution by VitaliyTheKeyboardist #36687

// your answers
type MyPick<T, K extends keyof T> = { 
[key in K]: T[key]
 }

Solution by desertby #36639

type MyPick<T, Y extends keyof T> = Omit<T, keyof Omit<T, Y>>

Solution by grishbar #36634

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

T

• type variable

K extends keyof T

• K is T's key OR keys

[P in K]: T[P]

• mapped type

Solution by kimdaeyeob #36618