Ts体操集合

Readonly (只读)

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

type Person = { 
    name:string
    age: number
}
type X = Readonly<Person>
const x: X = { name: 'John', age: 42 };
x.name = 'vino'  //error: Cannot assign to 'name' because it is a read-only property

Mutable (可变的)

type Person = { name: string, age: number };

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

type X = Mutable<Readonly<Person>>

Partial (部分)

type Partial<T> = {
  [K in keyof T]?: T[K];
}

Required (必须)

type Person = { 
    name?:string
    age?: number
}
type Required<T> = {
    [K in keyof T]-?:T[K]  //还能 -？
}

type X = Required<Person>

Exclude (排除)

type Exclude<T,K> = T extends K ? never : T

type X = Exclude< 1 | 2 | 3, 3> // 1 | 2

Extract (提取)

type Extract<T, K> = T extends K ? T : never;

type X = Exclude< 1 | 2 | 3, 3 | 4>  // 3

Pick (选择)

type Person = { 
    name:string
    age: number
}
type Pick<T,K extends keyof T> = {
    [P in K]: T[P]
}
type X = Pick<Person,'name'>

Omit (省去)

type Person = { 
    name:string
    age: number
}

type Omit<T, K> = {
  [P in Exclude<keyof T, K>]: T[P];
}

type X = Omit<Person,'name'>

//官方写法
type Omit<T,K extends keyof any> =  Pick<T,Exclude<keyof T, K>>

TupleToObjec

const tuple = ['tesla', 'model 3', 'model X', 'model Y'] as const
 
type TupleToObject<T extends readonly any[]> ={
   [K in T[number]] : K 
} 

type result = TupleToObject<typeof tuple> 
// expected { tesla: 'tesla', 'model 3': 'model 3', 'model X': 'model X', 'model Y': 'model Y'}

FirstOfArray

type arr1 = ['a', 'b', 'c']
type arr2 = [3, 2, 1]

type First<T extends any[]> =  T extends [infer P, ...any[]] ? P : never  //infer关键字的使用 

type head1 = First<arr1> // expected to be 'a'
type head2 = First<arr2> // expected to be 3

# LengthOfTuple

type tesla = ['tesla', 'model 3', 'model X', 'model Y']
type spaceX = ['FALCON 9', 'FALCON HEAVY', 'DRAGON', 'STARSHIP', 'HUMAN SPACEFLIGHT']

type teslaLength = Length<tesla>  // expected 4
type spaceXLength = Length<spaceX> // expected 5

Awaited

type MyAwaited<T> = T extends Promise<infer P> ? (P extends Promise<any> ? MyAwaited<P> : P) : never 
//需要考虑递归的情况

type ExampleType = Promise<string>

type Result = MyAwaited<ExampleType> // string

If

type If<C, T, F> = C extends true ? T : F  

type A = If<true, 'a', 'b'>  // expected to be 'a'
type B = If<false, 'a', 'b'> // expected to be 'b'

Concat

type Concat<T extends any[],K extends any[]> = [...T,...K]

type Result = Concat<[1], [2]> // expected to be [1, 2]

Push

type Push<T extends any[], U> = [...T,U] 

type Result = Push<[1, 2], '3'> // [1, 2, '3']

Parameters

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

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

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