通过类型推断写出 T[Key]

function getPropValue<T extends object, Key extends keyof T>(obj: T, key: Key): T[Key] {
    return obj[key];
}

这里的 Key in keyof T 取出来是Type 'Key' is not assignable to type 'string | number | bigint | boolean | null | undefined'.需要要用交叉类型做合并；

type MapType<T> = {
    [
        Key in keyof T 
            as `${Key & string}${Key & string}${Key & string}`
    ]: [T[Key], T[Key], T[Key], T[Key]]
}

type res = MapType<{a: 1, b: 2}>;

递归复用做循环

举例：常用的递归推断

type ttt = Promise<Promise<Promise<Record<string, any>>>>

// 递归复用做循环。
// 如果T是一个Promise，它会递归地对提取出的U应用DeepPromiseValueType。
// 这里的infer是做类型推断，extends是使用条件语句。
type DeepPromiseValue<T> = T extends Promise<infer U> ? DeepPromiseValue<U> : T;

type res = DeepPromiseValue<ttt>;

给所有类型加上readonly

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

type res = Readonly<{a: 1, b: 2}>;

递归给所有类型加上readonly

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

const v = {
    k1: 1,
    k2: {
        k21: 2,
        k22: 3
    }
} as const; // 使用 as const 将对象定义为常量类型，确保所有属性都是只读的