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

Solution by vaclock #35269

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

Solution by Muntazir-sd #35193

/* 7 - Readonly

by Anthony Fu (@antfu) #easy #built-in #readonly #object-keys

Question

Implement the built-in Readonly<T> generic without using it.

Constructs a type with all properties of T set to readonly, meaning the properties of the constructed type cannot be reassigned.

For example:

interface Todo {
  title: string
  description: string
}

const todo: MyReadonly<Todo> = {
  title: "Hey",
  description: "foobar"
}

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

View on GitHub: https://tsch.js.org/7 */

/* _____________ Your Code Here _____________ */

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

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

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

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

/* _____________ Further Steps _____________ / /

Share your solutions: https://tsch.js.org/7/answer View solutions: https://tsch.js.org/7/solutions More Challenges: https://tsch.js.org */

Solution by leetflow #35154

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

Solution by JAGORING #35145

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

Solution by lwfxzz #35117

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

Solution by chenweiCwCw #35079

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

Solution by koplec #35043

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

Define a new type by adding the readonly keyword to all properties of the generic type T.

Solution by miju-Park #34948

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

Solution by raeyoung-kim #34889

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

Solution by floatDreamWithSong #34868

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

Solution by 56aiden90 #34866

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

Solution by HrOkiG2 #34827

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

Solution by eunsukimme #34807

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

Solution by heryTz #34795

문제 설명

T의 모든 프로퍼티를 읽기 전용(재할당 불가)으로 바꾸는 내장 제네릭 Readonly<T>를 이를 사용하지 않고 구현하세요.

interface Todo {
  title: string;
  description: string;
}

const todo: MyReadonly<Todo> = {
  title: "Hey",
  description: "foobar",
};

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

readonly 속성 ?

readonly는 타입 객체의 key 앞에 붙여주면서 사용할 수 있으며 읽기 전용 속성이므로 수정이 불가능하게 한다.

구체적으로 초기화는 가능하며 변경이 안된다.

interface Todo {
  readonly title: string;
  readonly description: string;
}

const firstTodo: Todo = {
  title: "typescript",
  description: "study",
};

firstTodo.title = "javascript"; // error

풀이

Readonly 유틸리티 타입을 사용하지 않고 직접 구현하는게 문제이므로 가져온 타입을 T, 해당 타입 객체의 키를 유니온형태로 추출하고 순회하기 위해 in과 keyof 키워드를 활용한 맵드타입으로 문제를 해결하였습니다.

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

Solution by MyeonghoonNam #34788

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

Solution by Kim-Ji-Seop #34786

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

Solution by Oyeins-GUI #34780

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

Solution by kang-kibong #34741

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

Solution by lephuthuc2001 #34696

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

Solution by raeyoung-kim #34680

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

Solution by Skadelig #34671

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

迭代T的key组成的联合类型，并追加只读操作符

Solution by oOzhuoxiaOo #34670

// 你的答案

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

Solution by zeyuanHong0 #34666

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

Solution by nathan2slime #34653

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

const data:MyReadonly<Todo1> = {
  title: "shinn thant",
  description:"This is description",
  completed:true,
  meta: {
    author:"awesome"
  }
}

Solution by devshinthant #34516

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

Solution by JayoonKoo #34514

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

Solution by ktim816 #34418

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

Solution by gobielJonathan #34393

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

解析：通过映射类型的readonly修饰符可进行对应的实现

Solution by ICE-XIAOWU #34381

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

Solution by YeongseoYoon #34375