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

Solution by amirdaGankhuyag #37514

// 你的答案

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

Solution by Kind87 #37495

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

Solution by Lemoneey #37494

// first thing i did was 
type MyReadonly<Type> = Readonly<Type>

// then this is my custom
type MyReadonly<Type> = {
  readonly [Key in keyof Type]: T[Key];
};

Solution by Muntazir-sd #37428

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

• <T>

  • A single generic parameter.
  • T represents the type you want to make readonly (the whole interface).

• [P in keyof T]

  • A mapped type that iterates over each property key of T.
  • For every property P inside keyof T, a corresponding property will be created in the resulting type.

• readonly modifier

  • Applied before each property in the mapped type.
  • Ensures that once a value is assigned to this property, it cannot be reassigned (properties become immutable).

• T[P]

  • For each key P, this looks up its property type from T.
  • Example: if P = "completed" and T = Todo, then T[P] = boolean.

---

In plain words

MyReadonly<T> constructs a new type by:

1. Taking all properties of T.
2. Keeping their original types.
3. Marking every property as readonly so they cannot be reassigned.

Solution by 3aluw #37420

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

对于代码体部分的获取集合：

1. keyof T 的作用是获取键的集合
2. 映射类型需要遍历的"集合" [P in keyof T] 的语法结构是： in - 遍历操作符 keyof T - 要遍历的集合（属性名的联合类型） P - 当前遍历的项

对于泛型部分的约束：

// 有约束的 Pick - 安全 type SafePick<T, K extends keyof T> = { [P in K]: T[P]; // ✅ 安全：P 一定是 T 的键 };

// 无约束的 Pick - 危险（实际上无法这样写） type UnsafePick<T, K> = { [P in K]: T[P]; // ❌ P 可能不是 T 的键 }; K extends keyof T- 约束 K 只能是 T 的键的联合类型

TypeScript 提供了多个类似的"修饰符 ↔ 工具类型"对：

1. 可选属性相关

// ? 修饰符
interface User {
  name: string;
  phone?: string;  // 可选属性
}

// Partial<T> 工具类型
type PartialUser = Partial<User>;
// 等价于：{ name?: string; phone?: string }

2. 必选属性相关

// -? 移除可选性（在工具类型中使用）
type Required<T> = {
  [P in keyof T]-?: T[P];
}

interface User {
  name: string;
  phone?: string;
}

type RequiredUser = Required<User>;

// 等价于：{ name: string; phone: string }

3. 映射修饰符组合 工具类型可以组合不同的修饰符：

// 只读且可选
type ReadonlyPartial<T> = Readonly<Partial<T>>;

// 移除了只读但保持可选  
type MutablePartial<T> = {
  -readonly [P in keyof T]?: T[P];
}

// 你的答案

Solution by nyk233233 #37414

// 你的答案
/**
 * @description 
 * [K in keyof T] - keyof取出T中的所有键后，使用in遍历这个联合类型
 * T[K] - 获得T中的每一个键对应的类型
 * readonly - 添加readonly关键字，使每一项变为只读
 */
type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by lToBContinued #37408

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

Solution by ivan-abdulin #37357

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