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

Solution by minseonkkim #37343

// your answers

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

Solution by webMasterMrBin #37335

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

Solution by Nakamura25257 #37254

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

1. readonly 修饰属性只读
2. keyof T 取类型 T 所有属性名返回联合类型
3. in + 联合类型，返回对象类型 key

Solution by djdidi #37117

type MyReadonly = { readonly [Prop in keyof Obj]: Obj[Prop] };

Notes:

• extends (in a generic constraint): restricts the type parameter to types assignable to the type following extends.
• readonly: marks each property in the mapped type as read-only; the property types remain the same (Obj[Prop]).

Solution by Dessouki98 #37055

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

Solution by 359Steve #37011

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

Solution by mag123c #36992

// your answers

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

Solution by akbq2008 #36991

// this is too easy
type MyReadonly<T> = {
  readonly [P in keyof T]: T[P];
}

Solution by YiShengYouNi #36970

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

example of keyof

const human={
name:"XYZ",
age:10
}
const keys= keyof human;
// here keys = name | age

Solution by Anonymous961 #36957

/* 7 - 对象属性只读

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

题目

不要使用内置的Readonly<T>，自己实现一个。

泛型 Readonly<T> 会接收一个 泛型参数，并返回一个完全一样的类型，只是所有属性都会是只读 (readonly) 的。

也就是不可以再对该对象的属性赋值。

例如：

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

在 Github 上查看：https://tsch.js.org/7/zh-CN */

/* _____________ 你的代码 _____________ */

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

/* _____________ 测试用例 _____________ */ 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 } }

/* _____________ 下一步 _____________ / /

分享你的解答：https://tsch.js.org/7/answer/zh-CN 查看解答：https://tsch.js.org/7/solutions 更多题目：https://tsch.js.org/zh-CN */

Solution by wzjiscode #36954

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

Solution by zhangchenen #36952

解题思路

只需要在遍历的时候将属性设置为只读即可，此处需要用到typescript中的修饰符readonly

题解

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

心得与知识点

::: tip typescript 中的修饰符

1. public：公共修饰符，可以被类的实例、子类和外部访问。默认情况下，类的成员都是公共的。
2. private：私有修饰符，只能被类的内部访问。私有成员对于外部是不可见的，子类也无法访问。
3. protected：受保护修饰符，可以被类的内部和子类访问，对于外部是不可见的。
4. readonly：只读修饰符，表示成员只能在声明时或构造函数内部被赋值，之后不可修改。
5. static：静态修饰符，用于定义类级别的成员，而不是实例级别的成员。静态成员可以通过类名直接访问，而不需要创建实例。
6. abstract：抽象修饰符，用于声明抽象类和抽象方法。抽象类不能被实例化，只能被继承，并且子类必须实现抽象方法。

:::

Solution by lkwavestian #36944

// 你的答案

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

Solution by rzy12345 #36926

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

Solution by AlexBraunMagic #36920

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

Solution by shaishab316 #36838

type MyReadonly<T> = {
  readonly[P in keyof T]: T[P];
}  //Here we change from 'any' on this 

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 GormanProg123 #36813

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

Solution by BernTheSeal #36808

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

Solution by Huiyong-Chen #36801

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 AnastasiaSv #36759

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

Solution by Abdullah-Elsayed01 #36743

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

Solution by Mamdouhreda #36705

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

Solution by seungdeok #36686

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

Solution by desertby #36640

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

Solution by kimdaeyeob #36635

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

Solution by wiJeeXu #36597

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

Solution by ae-hyon #36587

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

Solution by MrSissel #36578

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

Solution by mola-fish #36573

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

Solution by ChemieAi #36547