00007-easy-readonly

Back

type MyReadonly<T> = {
  readonly [P in keyof T]: T[P]
}

Solution by notsecret32 #33605


type MyReadonly<T> = {
  readonly [key in keyof T]: T[key]
}

Solution by okasyun #33593

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

Solution by Jaewoneeee #33570

type MyReadonly<T extends Record<string, any>> = {
  readonly [K in keyof T]: T[K]
}

Solution by Danny101201 #33563

type MyReadonly<T> = {
  readonly [t in keyof T]: T[t]
}

Solution by oo009pbh #33546

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by Kolufs #33517

type MyReadonly<T> = {
  readonly [key in keyof T] : T[key]
}

Solution by brown2243 #33462

type MyReadonly<T> = {
  // 각 항목들을 readonly 를 붙여서 타입 매핑 구문을 진행
  readonly [k in keyof T]: T[k]
}

Solution by kukjun #33453

/* _____________ Your Code Here _____________ */

type MyReadonly<T> = {readonly[P in keyof T]: T[P]}

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

type cases = [
  Expect<Equal<MyReadonly<Todo1>, Readonly<Todo1>>>,
]

interface Todo1 {
  title: string
  description: string
  completed: boolean
  meta: {
    author: string
  }
}

Solution by happy4 #33390

// 你的答案'
type MyReadonly<T extends object> = {
  +readonly[key in keyof T]: T[key]
}

Solution by chenjieya #33348

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by adultlee #33335

// 你的答案
type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by lvdengming #33329

// 여기 풀이를 입력하세요
type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by awesomelon #33319

type MyReadonly<T> ={
  readonly [P in keyof T]:T[P]
}

Solution by Skytim #33287

// 你的答案
type MyReadonly<T> = {
  readonly [key in keyof T]:T[key]
}

Solution by hellolukeding #33202

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by daishi-motoyama #33185

/* _____________ 你的代码 _____________ */

type MyReadonly<T> = {readonly [k in keyof T]:T[k]}

/* _____________ 测试用例 _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<MyReadonly<Todo1>, Readonly<Todo1>>>,
]

interface Todo1 {
  title: string
  description: string
  completed: boolean
  meta: {
    author: string
  }
}

Solution by justingcode #33169

// your answers
  type MyReadonly<T> = {
    readonly [key in keyof T]: T[key]
  }

Solution by DaniilPoverzhuk #33162

type MyReadonly<T> = {
  readonly[P in keyof T] : T[P]
}

Solution by seoksanghwan #33158

// your answers
type MyReadonly<T> = {
  readonly [P in keyof T]: T[P];
};

Solution by sarda10v #33155

type MyReadonly<T> = {
  readonly [K in keyof T]:T[K]
}

Solution by Tubring25 #33148

type MyReadonly<T> = {
  readonly [key in keyof T]:T[key]
}

Solution by loevray #33136

type MyReadonly<T> = {
  readonly [k in keyof T]:T[k]
}

Solution by XiaofeiCY #33098

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by hanseulhee #33094

type MyReadonly<T> = { readonly [key in keyof T]: T[key]};

Solution by AndyRadulescu #33070

type MyReadonly<T> = {
  readonly [P in keyof T]: T[P]
}

Solution by javad7z7 #33052

type MyReadonly<T> = {
  readonly [k in keyof T]: T[k]
}

Solution by sachin-toku #33033

type MyReadonly<T> = {
  readonly[K in keyof T] : T[K]
}

Solution by RanungPark #33029

// 你的答案
type MyReadOnly<T> =   {
  readonly [Key in keyof T]: T[Key] extends object ? MyReadOnly<T[Key]> : T[Key]
}

Solution by ry928330 #32997

// 你的答案

type MyReadonly = { readonly [K in keyof T]: T[K] }

Solution by DwayneDuanJY #32979