sufuwang
commented
1 year ago TypeScript 内置类型
Parameters
type Func = (obj: 1, other: 'other') => void
type MyParameters<Fn> = Fn extends (...args: infer T) => any ? T : any
// [obj: 1, other: "other"]
type P1 = Parameters<Func>
type P2 = MyParameters<Func>ReturnType
type Func = (obj: 1, other: 'other') => [1, 'A']
type MyReturnType<Fn> = Fn extends (...args: any) => infer T ? T : any
// [1, "A"]
type P1 = ReturnType<Func>
type P2 = MyReturnType<Func>ConstructorParameters
interface Func1 {
new (obj: 1, other: 'other'): [1, 'A']
}
type Func2 = new (obj: 1, other: 'other') => [1, 'A']
type MyConstructorParameters<Fn extends abstract new(...args: any) => any> =
Fn extends new (...args: infer T) => any ? T : any
// [obj: 1, other: "other"]
type P1 = ConstructorParameters<Func1>
type P2 = MyConstructorParameters<Func1>
type P3 = ConstructorParameters<Func2>
type P4 = MyConstructorParameters<Func2>InstanceType
interface Func1 {
new (obj: 1, other: 'other'): [1, 'A']
}
type Func2 = new (obj: 1, other: 'other') => [1, 'A']
type MyInstanceType<Fn extends abstract new(...args: any) => any> =
Fn extends new (...args: any) => infer T ? T : any
// [1, "A"]
type P1 = InstanceType<Func1>
type P2 = MyInstanceType<Func1>
type P3 = InstanceType<Func2>
type P4 = MyInstanceType<Func2>ThisParameterType
interface Person {
name: string;
age: number;
}
type MyThisParameterType<Fn extends (this: any, ...args: any) => any> =
Fn extends (this: infer T) => any ? T : unknown
type Func = (this: Person) => void
// Person
type P1 = ThisParameterType<Func>
type P2 = MyThisParameterType<Func>OmitThisParameter
interface Person {
name: string;
age: number;
}
type MyOmitThisParameter<Fn extends (this: any, ...args: any) => any> =
Fn extends (this: any, ...args: infer T) => infer R ? (...args: T) => R : unknown
type Func = (this: Person, name: Person['name'], age: 12) => Person
// (name: string, age: 12) => Person
type P1 = OmitThisParameter<Func>
type P2 = MyOmitThisParameter<Func>Partial
interface Person {
name: string;
age: number;
}
type MyPartial<T extends Record<any, any>> = {
[K in keyof T]?: T[K]
}
// { name?: string | undefined; age?: number | undefined; }
type P1 = Partial<Person>
type P2 = MyPartial<Person>Required
interface Person {
name: string;
age: number;
}
type PartialPerson = Partial<Person>
type MyRequired<T extends Record<any, any>> = {
[K in keyof T]-?: T[K]
}
// { name: string; age: number; }
type P1 = Required<PartialPerson>
type P2 = MyRequired<PartialPerson>Readonly
interface Person {
name: string;
age: number;
}
type MyReadonly<T extends Record<any, any>> = {
readonly [K in keyof T]: T[K]
}
// { name: string; age: number; }
type P1 = Readonly<Person>
type P2 = MyReadonly<Person>Pick
interface Obj {
a: 'A';
b: 'B';
1: '1';
2: '2';
}
type MyPick<O extends Record<string, any>, KeyS extends keyof O> = {
[Key in KeyS]: O[Key]
}
// { a: 'A'; 1: '1'; }
type a = Pick<Obj, 'a' | 1>
type b = MyPick<Obj, 'a' | 1>Record
// string | number | symbol
type a = string | number | symbol
type b = keyof any
type MyRecord<K extends keyof any, T> = {
[Key in K]: T
}
// { 1: void; a: void; }
type P1 = Record<1 | 'a', void>
type P2 = MyRecord<1 | 'a', void>Exclude
type MyExclude<K extends keyof any, T> = K extends T ? never : K
// symbol | "a"
type P1 = Exclude<1 | 'a' | symbol, 1>
type P2 = MyExclude<1 | 'a' | symbol, 1>Extract
type MyExtract<K extends keyof any, T> = K extends T ? K : never
// symbol | 1
type P1 = Extract<1 | 'a' | symbol, 1 | symbol>
type P2 = MyExtract<1 | 'a' | symbol, 1 | symbol>Omit
interface Person {
name: string;
age: number;
}
type MyOmit<K extends Record<string, any>, T> = Pick<K, Exclude<keyof K, T>>
// { age: number; }
type P1 = Omit<Person, 'name'>
type P2 = MyOmit<Person, 'name'>Awaited
type MyAwaited<T extends Promise<any>> =
T extends Promise<infer K>
? K extends Promise<any> ? MyAwaited<K> : K
: T
// [1]
type P1 = Awaited<Promise<[1]>>
type P2 = MyAwaited<Promise<[1]>>
type P3 = Awaited<Promise<Promise<[1]>>>
type P4 = MyAwaited<Promise<Promise<[1]>>>
type P5 = Awaited<Promise<Promise<Promise<[1]>>>>
type P6 = MyAwaited<Promise<Promise<Promise<[1]>>>>NonNullable
type MyNonNullable<T> = T extends null | undefined ? never : T
// Promise<[1]>
type P1 = NonNullable<Promise<[1]>>
type P6 = MyNonNullable<Promise<[1]>>
// never
type P2 = NonNullable<null>
type P3 = NonNullable<never>
type P4 = NonNullable<undefined>
type P7 = MyNonNullable<null>
type P8 = MyNonNullable<never>
type P9 = MyNonNullable<undefined>
// void & {}
type P5 = NonNullable<void>
// void
type P10 = MyNonNullable<void>
学习一下 ts 零碎的知识点