00006-extreme-readonly-keys

[yunliuyan]

获取只读字段

by Anthony Fu @antfu

   

实现泛型GetReadonlyKeys<T>，GetReadonlyKeys<T>返回由对象 T 所有只读属性的键组成的联合类型。

例如

interface Todo {
  readonly title: string
  readonly description: string
  completed: boolean
}

type Keys = GetReadonlyKeys<Todo> // expected to be "title" | "description"

测试案例:

import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<'title', GetReadonlyKeys<Todo1>>>,
  Expect<Equal<'title' | 'description', GetReadonlyKeys<Todo2>>>,
]

interface Todo1 {
  readonly title: string
  description: string
  completed: boolean
}

interface Todo2 {
  readonly title: string
  readonly description: string
  completed?: boolean
}

[yunliuyan]

思路

遍历对象key值，若对应的属性继承了Readonly则取当前值。

代码实现:

 type GetReadonlyKeys<T> = {
    [key in keyof T ]-?: Equal<Pick<T, key>, Readonly<Pick<T, key>>> extends true ? key : never
  }[keyof T];

类型映射变体

• readonly：用于将所有属性设置为只读属性，例如 { readonly [P in keyof T]: T[P] }。
• ?：用于将所有属性设置为可选属性，例如 { [P in keyof T]?: T[P] }。
• -?：用于将所有属性设置为必选属性，例如 { [P in keyof T]-?: T[P] }。
• +：用于将所有属性设置为只读和可选属性，例如 { +readonly [P in keyof T]+?: T[P] }。

[wudu8]

export type ExtremeReadOnly<T> = {
    [K in keyof T]-?: (<U>() => U extends { -readonly [P in K]: T[K] } ? 1 : 2) extends <U>() => U extends { [P in K]: T[K] } ? 1 : 2 ? never : K;
}[keyof T];

interface ExtremeReadonlyType {
    readonly name: string;
    address: boolean;
    readonly meta: {
        description: string;
    };
    description: string;
}

type extremeReadonlyTest = ExtremeReadOnly<ExtremeReadonlyType>;

const extremeReadonlyTest1: extremeReadonlyTest = "name"; // Ok
const extremeReadonlyTest2: extremeReadonlyTest = "address"; // Error: Type '"description"' is not assignable to type 'extremeReadonlyTest'.ts(2322)
const extremeReadonlyTest3: extremeReadonlyTest = "meta"; // Ok
const extremeReadonlyTest4: extremeReadonlyTest = "description"; // Error: Type '"description"' is not assignable to type 'extremeReadonlyTest'.ts(2322)

[Janice-Fan]

type Equal<X, Y> = (() => T extends X ? 1 : 2) extends (() => T extends Y ? 1 : 2) ? true : false;

type GetReadonlyKeys = keyof {

}

interface Todo { readonly title: string readonly description: string completed: boolean }

type Keys = GetReadonlyKeys // expected to be "title" | "description"

const test: Keys = 'title';

[liangchengv]

type GetReadonlyKeys<T> = {
  [P in keyof T as Equal<Pick<T, P>, Readonly<Pick<T, P>>> extends true ? P: never]: T[P]
}[keyof T];

[Naparte]

type Equals<X, Y> =
    (<T>() => (T extends X ? 1 : 2)) extends
    (<Z>() => (Z extends Y ? 1 : 2))
    ? true
    : false;
// https://juejin.cn/post/7078208046283014158

type GetReadonlyKeys<T> = { [key in keyof T]: Equals<Pick<T, key>, Readonly<Pick<T, key>>> extends true ? key : never }[keyof T]

interface Todo6 {
    readonly title: string
    readonly description: string
    completed: boolean
}

type Keys = GetReadonlyKeys<Todo6> // expected to be "title" | "description"