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

Solution by Katlego-Sekoele #37940

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

Solution by doseong13 #37939

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

Solution by LoveDreaMing #37901

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

Solution by ClarityOfMind #37873

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

Solution by tuannvnguyen #37868

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

Solution by istamal #37847

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

Solution by Hansol46 #37830

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

Solution by pkutsenko #37819

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

Solution by LovePlayCode #37794

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

Solution by liuyee12 #37787

// 你的答案

type MyReadonly = { readonly [K in keyof T]: T[K] } // 使用keyof获取到类型的键，然后用readonly修饰符修饰键

Solution by dong-hx #37782

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

Solution by jisooooooooooo #37779

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

Solution by jthw1005 #37741

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

Solution by GuoYingHAOG #37718

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

Solution by binh-nguyen-tran-thanh #37697

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

Solution by ortima #37685

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 PosionEdgar #37676

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

Solution by AlexanderNP #37643

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

Solution by imobidjon #37619

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

Solution by jjojae9393 #37596

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

Solution by tomo-local #37570

// your answers

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

Solution by PAVANT009 #37558

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