Type Challenges: 00008-medium-readonly-2 Solution

// your answers
type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [key in keyof T as key extends K ? key : never]: T[key];
} & {
  [key in keyof T as key extends K ? never : key] : T[key]
};

Solution by nupthale #33556

type MyReadonly2<T, K extends keyof T = keyof T> = & Readonly<Pick<T, K>> & Omit<T, K>

Solution by Kolufs #33536

type MyReadonly2<T, K extends keyof T = keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P];
} & {
  readonly [P in K]: T[P];
};

Solution by itskalender #33430

// 여기 풀이를 입력하세요
type MyExclude<T, U> = T extends U ? never : T;
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };
type MyReadonly<T> = { readonly [K in keyof T]: T[K] };

type MyReadonly2<T, K extends keyof T = keyof T> = MyPick<T, MyExclude<keyof T, K>> &  MyReadonly<T>;

Solution by awesomelon #33389

// your answers
type ExcludeOption<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

type PickOption<T, K extends keyof T> = Pick<T, K>;

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

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

type MyReadonly2<T, K extends keyof T = keyof T> = Flatten<
  ExcludeOption<T, K> & ReadonlyOption<T, keyof PickOption<T, K>>
>;

// 测试用例

type Test1 = MyReadonly2<Todo1, "description">;
type Test1 = MyReadonly2<Todo1>;

Solution by nuonuonuonuoyan #33333

type MyReadonly2<T, K extends keyof T = keyof T> = { readonly [P in K]: T[P] } & { [P in keyof T as P extends K ? never: P]: T[P] }

Solution by PrakashC1 #33266

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in keyof T as P extends K ? P : never]: T[P]
} & {
  [P in keyof T as P extends K ? never : P]: T[P]
}

Solution by Tubring25 #33222

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P]
} & {
  [P in keyof T as P extends K ? never : P]: T[P]
}

Solution by loevray #33213

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P];
} & Omit<T, K>;

Solution by KenjiGinjo #33089

// 你的答案
type MyReadonly2<T, K extends keyof T = keyof T> = {
  [key in keyof T as  key extends K ? never : key]:T[key]
} & {
  readonly [key in K]:T[key]
}

Solution by walker-hzx #32932

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]:T[P]
} & {
  [P in keyof T as P extends K ? never : P]:T[P]
}

Solution by CAN1177 #32854

// 解答をここに記入
type MyReadonly<T, K extends keyof T> = { readonly [Key in K]: T[Key] };

type MyExclude<T, K> = T extends K ? never : T;

type MyReadonly2<T, K extends keyof T = keyof T> = MyReadonly<T,K> & {
  [Key in keyof T as MyExclude<Key, K>]: T[Key]
}

型引数Kは省略が可能な引数にするため、『デフォルト型引数』で定義。
MyReadonlyを定義し与えられたTオブジェクトの各プロパティをすべてreadonlyに変更。
MyReadonlyで作成したT'オブジェクトに、Kで与えられたプロパティ以外のreadonlyではないプロパティを持つオブジェクトをマージ
- キー部分を『型アサーション』とMyExcludeを使用して、Tオブジェクトの中からKを除外したTオブジェクトのプロパティキーに設定。

Solution by Yasunori-aloha #32803

type MyReadonly2<T extends Record<keyof T, unknown>, Keys> = {
    readonly [K in keyof T]: T[K]
} & {
    -readonly [K in keyof T as K extends Keys ? never : K]: T[K]
}

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

const todo: MyReadonly2<Todo, 'title' | 'description'> = {
  title: "Hey",
  description: "foobar",
  completed: false,
}

todo.title = "Hello" // Error: cannot reassign a readonly property
todo.description = "barFoo" // Error: cannot reassign a readonly property
todo.completed = true // OK

Solution by ZhulinskiiDanil #32667

type MyReadonly2<T, K extends keyof T = keyof T> = {
  [p in keyof T as p extends K ? never : p]: T[p];
} & {
  readonly [p in keyof T as p extends K ? p : never]: T[p];
}

但是我更喜欢这个实现 https://github.com/type-challenges/type-challenges/issues/1721 ：

type MyReadonly2<T, K extends keyof T = keyof T> = Omit<T, K> & Readonly<Pick<T, K>>;

Solution by mistkafka #32633

// 你的答案
type MyReadonly2<T, K extends keyof T = keyof T> = Omit<T, K> & { readonly [P in K]: T[P] };

Solution by xachary #32548


type MyReadonly2<T, K extends keyof T = keyof T> = Omit<T, K> &
  Readonly<Pick<T, K>>;

Solution by wubrafiq807 #32546

// 你的答案

Solution by wrq1663 #32448

// your answers
type MyReadonly2<T, K extends keyof T = keyof T> = Omit<T, K> & Readonly<Pick<T, K>>

Solution by leehave #32413

type MyReadonly2<T, K extends keyof T> = Omit<T, K> & Readonly<Pick<T, K>>

Solution by laqudee #32331

type MyReadonly2<T, K extends keyof T = keyof T> = { [P in Exclude<keyof T, K>]: T[P]; } & { readonly [P in K]: T[P]; };

Solution by Mutter45 #32238

type MyReadonly2<T, K extends keyof T = keyof T> = 
  { 
    readonly [P in keyof T as P extends K ? P : never]: T[P]
  } & 
  { 
    [P in keyof T as P extends K ? never : P]: T[P]
  }

Solution by dev-hobin #32170

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [Key in K]: T[Key]
} & Pick<T, Exclude<keyof T, K>>

We split the solution in two parts (divided by the union &)

In the first part, we make readonly only the keys provided in K, if K is not provided, then it takes the value of all keys using a default type Then we join the result type with the rest of the keys that are not readonly specified using Pick and omit the keys already used using Exclude

Solution by joyanedel #32138

type MyExlude<T, K> = T extends K ? never : T; type MyReadonly2< T,K extends keyof T> = { readonly [k in K]: T[k]} & { [k in MyExlude<keyof T, K>]: T[k] }

Solution by rkamely #32052

// your answers
type MyReadonly2<T, K = keyof T> = {
  readonly [Properties in keyof T as Properties extends K ? Properties : never]: T[Properties]
} & {
  [Properties in keyof T as Properties extends K ? never : Properties]: T[Properties]
}

Solution by trinhvinhtruong96 #32031

// 你的答案
type MyReadonly2<T, U extends keyof T = keyof T> = Omit<T, U> & Readonly<Pick<T, U>>

Solution by ruofee #32013

思路：对于 MyReadonly2<T, K> ，首先将 T 中 K 包含的所有属性变为只读，然后合并不在 K 中的属性

可能存在的难点如下：

如何解决泛型类型 MyReadonly2 接受两个参数，但是第二个参数是可选的
重写为 readonly 的类型如何和没有改变的类型合并

解决：

给类型参数一个默认的值，即可变成可选类型参数
使用 & 完成两种类型的合并

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [key in K]: T[key]
} & {
    [key in keyof T as key extends K ? never : key]: T[key]
  }Ï

Solution by tototi5997 #31925

// your answers
type MyReadonly2<T extends object, K extends keyof T= keyof T> = {
  readonly   [P in keyof T as P extends K ? P : never]: T[P]
} & {
  [P in keyof T as P extends K ? never : P]: T[P]
}

Solution by pea-sys #31799

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

const todo: MyReadonly2<Todo, 'title' | 'description'> = {
  title: "Hey",
  description: "foobar",
  completed: false,
}

todo.title = "Hello" // Error: cannot reassign a readonly property
todo.description = "barFoo" // Error: cannot reassign a readonly property
todo.completed = true // OK

type MyReadonly2<T, S extends string> {
  readonly [key in keyof T as key extends S ? key : never]: T[key]
} & {
  [key in keyof T as key extends S ? never : key]: T[key]
}

Solution by anovicenko74 #31756

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [U in keyof T as U extends K ? U : never]: T[U]
} & {
  [U in keyof T as U extends K ? never : U]: T[U]
}

Solution by chaosspace #31692

type MyReadonly2<T, K extends keyof T = keyof T> = {readonly [key in K]: T[key]} & Pick<T, Exclude<keyof T, K>>

Solution by kai-phan #31617