TypeScript 类型定义-2

// Omit: 实现 TypeScript 的 Omit<T, K> 泛型

type MyOmit<T, U extends keyof T> = {
    [K in Exclude<keyof T, U>]: T[K];
}

// Readonly: K指定应设置为 Readonly的T的属性集。如果未提供K，则应使所有属性都变为只读

type MyReadonly<T, U extends keyof T> = Omit<T, U> & Readonly<Pick<T, U>>;

// DeepReadonly: 将对象的每个参数及其子对象递归地设为只读(对象)

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

// PromiseAll: 它接受PromiseLike对象数组，返回值应为Promise<T>，其中T是解析的结果数组。

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{
    [K in keyof T]: Awaited<T[K]>;
}>;

// TrimLeft: 接收确定的字符串类型并返回一个新的字符串，其中新返回的字符串删除了原字符串开头的空白字符串。

type TrimLeft<T extends string> = T extends `${' ' | '\t' | '\n'}${infer U}` ? TrimLeft<U> : T;

// Trim

type Trim<T extends string> = T extends `${infer U}${' ' | '\t' | '\n'}` ? Trim<U> : TrimLeft<T>;

// Last: 它接受一个数组T并返回其最后一个元素的类型

type Last<T extends any[]> = T extends [...infer R, infer L] ? L : never;

// Pop: 它接受一个数组T，并返回一个由数组T的前length-1项以相同的顺序组成的数组。

type Pop<T extends any[]> = T extends [...infer R, infer L] ? R : [];

// Chainable: 可串联，其中两个函数 option(key, value) 和 get()

type Chainable<T> = {
    option<K extends string, U>(key: K, value: U): Chainable<T & Record<K, U>>;
    get(): T
}

// ReturnType: typeScript 的 ReturnType<T> 泛型。

type MyReturnType<T extends Function> = T extends (...args: any[]) => infer U ? U : never;

// TupleToUnion: 实现泛型 TupleToUnion<T>，它返回元组所有值的合集。

type TupleToUnion<T extends readonly unknown[]> = T[number];

// LookUp: 在联合类型 Cat | Dog中搜索公共type字段来获取相应的类型

type LookUp<U, T> = U extends { type: T } ? U : never;

interface Cat {
    type: 'cat'
    breeds: 'Abyssinian' | 'Shorthair' | 'Curl' | 'Bengal'
}
interface Dog {
    type: 'dog'
    breeds: 'Hound' | 'Brittany' | 'Bulldog' | 'Boxer'
    color: 'brown' | 'white' | 'black'
}
type MyDog = LookUp<Cat | Dog, 'dog'> // expected to be `Dog`