手写常见的typescript类型

1.Pick

type myPick<T,K extends keyof T> = { [key in K]:T[key] }

2.Readonly

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

3.Tuple to Object

const tuple = ['a','b','c']

type TupleToObject<T extends readonly PropertyKey[]> = {
    [P in T[number]] : P
} 

type resTuple = TupleToObject<typeof tuple> // 为{'a':'a','b':'b','c':'c'}

4.First Of Array

type First<T extends any[]> = T extends [] ? never : T[0]

5.Length of Tuple

type LengthOfTuple<T extends readonly any[]> = T['length']

6.Exclude

// 运用extends的第二个用法，即 Distributive Conditional Types.
// T extends U 会分发性的把T的每个项去判断是否等于'a'
// https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
// 按官网的例子而言，我们假如需要一个string和number组合而成的数组类型，即(string | number)[]
// 写成type ToArray<Type> = Type extends any ? Type[] : never 导致 string[] | number[]，由于Distributive Conditional Types的特性
//因此需要拿[]包裹，即type ToArray<Type> = [Type] extends [any] ? Type[] : never
type MyExclude<T,U> = T extends U ? never : T
type Result = MyExclude<'a' | 'b' | 'c', 'a'> // 'b' | 'c'

6.PickPartial

// 开发者在泛型里输入两个参数，interface和某个值并把它置为可选
interface User {
    id: number;
    age: number;
    name: string;
};

type PickPartial<T,K extends keyof T> = Partial<Pick<T, K>> & Omit<T,K>
type Result = PickPartial<User, 'id'>
// {
//     id?: number;
//     age: number;
//     name: string;
// }

7.Awaited

// type ExampleType = Promise<string>

// type Result = MyAwaited<ExampleType> // string

type MyAwaited<T extends PromiseLike<any | PromiseLike<any>>> = T extends PromiseLike<infer P> ?
    P extends PromiseLike<any> ? MyAwaited<P> : P : never 

8.If

type MyIf<F extends boolean,T ,K> = F extends true ? T : F extends boolean ? K : never 

9.Concat

// For example:
// type Result = Concat<[1], [2]> 
// expected to be [1, 2]
type MyConcat<T extends readonly unknown[],K extends readonly unknown[]> = [...T,...K]

10.Includes

type MyIncludes<T extends any[],K> = { 
    [key in T]:T[key]
}[K] extends true ? true : false

11.Push

// type Result = Push<[1, 2], '3'> // [1, 2, '3']
type MyPush<T extends readonly unknown[],U> = [...T,U]

12.Unshift

// type Result = Push<[1, 2], '3'> // [1, 2, '3']
type MyPush<T extends readonly unknown[],U> = [U,...T]

13.Parameters

// const foo = (arg1: string, arg2: number): void => {}

// type FunctionParamsType = MyParameters<typeof foo> // [arg1: string, arg2: number]

type MyParameters<T extends (...args:any[]) => unknown> = T extends (...args:infer S) => unknown ? S : never