重拾ts类型体操

匹配模式做提取

1. 数组类型

• 提取数组第一个元素的类型

type GetFirst = Arr extends [infer First, ...unknown[]] ? First : never;

• 提取数组的最后一个元素的类型

type GetLast = Arr extends [...unknown[],infer Last] ? Last : never;

• 去掉数组最后一个元素的类型

type PopArr = Arr extends [] ? [] : Arr extends [...infer Result,unknown] ? Result : never;

• 去掉数组第一个元素的类型

type ShiftArr = Arr extends [] ? [] : Arr extends [unknown,...infer Result] ? Result : never;

2. 字符串类型

• 判断字符串是否以某个前缀开始

type StartWith = Str extends `${Start}${string}` ? true : false;

• 字符串替换

type ReplaceStr = Str extends `${infer Prefix}${From}${infer Suffix}` ?ReplaceStr<`${Prefix}${To}${Suffix}`,From,To> : Str

• 递归去除字符串中的右侧空格

type TrimStringRight = Str extends `${infer Result}${' '}` ? TrimStringRight : Str;

• 递归去除字符串中的左侧空格

type TrimStringLeft = Str extends `${' '}${infer Result}` ? TrimStringLeft : Str;

• 递归去除字符串中的左右侧空格

type TrimString = Str extends `${' '}${infer Result}${' '}` ? TrimString : Str;

3. 函数

• 提取参数的类型

type FunctionArgs = Fn extends (...args:infer Args) => unknown ? Args : never;

• 提取返回值

type FunctionResult = Fn extends (...args:any[]) => infer Result ? Result : never;

• 提取函数中的this

type FunctionThis = Fn extends (this:infer This,...args:unknown[])=>unknown ? This : never;

4. 构造器

• 匹配提取出实例对象

type GetInstanceTypeany> = Type extends new(...args:any) => infer Result ? Result : never;
// 测试案例
interface Person{name: string
}
interface PersonConstructor{new(name:string):Person
}
type person = GetInstanceType;

• 提取构造器的参数

type GetInstanceParamany> = Type extends new(...args:infer Result) => unknown ? Result : never;
// 测试案例
interface Person{name: string
}
interface PersonConstructor{new(name:void):Person
}
type person = GetInstanceParam;

5. 索引类型

• 提取ref的值的类型
  ts类型体操，提取ref的值的类型。

重新构造做变换

1. 数组类型的重新构造

• 向数组后面添加元素

type Push = [...Arr,Ele];

• 向数组前面添加元素

type Shift = [Ele,...Arr];

• 合并只有两个元素的两个元组对应的元素

type Concat = 
One extends [infer OneFirst, infer OneSecond] ?Two extends [infer TwoFirst, infer TwoSecond] ? [[OneFirst,OneSecond],[TwoFirst,TwoSecond]] : []
: []

• 合并只有任意个元素的两个元组对应的元素

type Concat = 
One extends [infer OneFirst,...infer OneOther] ?Two extends [infer TwoFirst,...infer TwoOther] ? [[OneFirst,TwoFirst],...Concat] : []
: [];

2. 字符串的重新构造

• 将字符串第一个元素转换成大写

type StringFistToUp = Str extends `${infer First}${infer Other}` ? `${Uppercase}${Other}` : never

• 删除字符串中的某个字串

type DeleteString = 
Str extends `${infer Start}${Ele}${infer End}` ? DeleteString<`${Start}${End}`,Ele> : Str

• 函数类型的重新构造

type FunAddParam =
Fn extends (...args:infer Args)=>infer Result ? (...args:[...Args,Arg])=>Result : never

3. 索引类型重新构造

• 把索引类型的Key变成大写

type KeyUp = {[Key in keyof Obj as Uppercase]:Obj[Key];
}

• Record，typescript内置了Record，用来创建索引类型。

type _Record = {[P in K]: T
}

• 将索引转换成只读

type ReadonlyParam = {readonly  [P in keyof T]: T[P]
}

• 给索引添加可选修饰符

type toSelector = {[P in keyof T]?: T[P]
}

• 去掉只读修饰符

type RemoveReadonly = {-readonly [P in keyof T]: T[P]
}

• 去掉可选修饰符

type ClearSelector = {[P in keyof T]-?: T[P]
}

• 对索引类型做过滤

type FilterValue,valueType extends unknown> = {[Key in keyof T as T[Key] extends valueType ? Key : never]: T[Key]
}

递归复用做循环

1. Promise的递归调用

• 提取不确定层数的Promise中的value类型的高级类型

type PromiseValue = 
T extends Promise?PromiseValue
: T
type promise = PromiseValue>>>

2. 数组类型的递归

• 不确定长度的元组反转

type ReverseArr> = T extends [infer First,...infer Other] ? [...ReverseArr,First] : T;

• 寻找元组中是否存在某个元素

type IsEqual = (A extends B ? true : false) & (B extends A ? true : false);
type Include = 
Arr extends [infer First,...infer Other] ?IsEqual extends true ? true : Include
: false;

• 删除元组中的某个元素

type RemoveArrItem = Arr extends [infer First,...infer Other] ?IsEqual extends true ? RemoveArrItem : RemoveArrItem
: Result
type IsEqual = (A extends B ? true : false) & (B extends A ? true : false)

• 构建一个自定义长度的同一类别的数组

type BuildArr = Arr['length'] extends Length ? Arr : BuildArr

3. 字符串类型的递归

• 将字符串中的所用的指定字串替换成另一个字符串

type Replace = Str extends `${infer Start}${From}${infer End}` ? Replace<`${Start}${To}${End}`,From,To> : Str

• 将字符串的每个元素提取出来转换成联合类型

type StrType = Str extends `${infer First}${infer Other}` ? StrType : Result

• 反转字符串类型

type ReverseString = Str extends `${infer First}${infer Other}` ? ReverseStringResult}${First}`> : Result

4. 对象类型的递归(索引类型的递归)

-递归将所有层的索引都变成只读
错误代码，如果测试一下我们就会发现，递归没有进行下去。因为ts的类型只有被用到的时候才会被计算。这里只是给第一次的索引加上了只读，但是没有使用。所以不会进行计算，我们可以加一个Obj extends any让其计算。

type DeepReadonly> = Obj extends any ? {readonly [Key in keyof Obj]: Obj[Key] extends Record ? Obj[Key] extends Function ? Obj[Key] : DeepReadonly: Obj[Key]
} : never

数组长度做计算

1. 数组长度实现加减乘除

• 加

type BuildArray = Result['length'] extends Length ? Result : BuildArray
type Add = Arr extends [infer Start extends number,...infer Other]? Add,...Result]> : Result['length']
type s = Add<[1,2,3]>

• 减

type BuildArray = Result['length'] extends Length ? Result : BuildArray
type SubTract = BuildArray extends [...BuildArray,...infer Result] ? Result['length'] : never

• 乘

type BuildArray = Result['length'] extends Length ? Result : BuildArray
type SubTract = BuildArray extends [...BuildArray,...infer Result] ? Result['length'] : nevertype Multiply = Num1 extends 0 ? Result['length'] : Multiply,Num2,[...Result,...BuildArray]>

• 除

type BuildArray = Arr['length'] extends Length ?Arr :BuildArray
type Subtract = BuildArray extends [...arr1: BuildArray, ...arr2: infer Rest] ?
Rest['length'] : nevertype Divide = Num1 extends 0 ?ResultArr['length'] :Divide,Num2,[unknown, ...ResultArr]>;
type divide = Divide<6,3>;

• 求字符串的长度的类型

type StrLen = Str extends `${string}${infer Rest}`? StrLen
: ResultArr['length'];
type str = StrLen<'123'>;

• 比较两个值的大小

type Than = Num1 extends Num2 ? false :Count['length'] extends Num2 ? true :Count['length'] extends Num1 ? false :Than

• Fibonacci 数列的计算

type Fi = Idx['length'] extends Num ? Right['length'] : Fitype Fib = Fi<[],[1],Num,[1]>

联合分散可化简

1. 将联合类型的字符串_去点，并将_后的第一个字母大写

type Tool = Str extends `${infer First}_${infer Start}${infer End}` ? Tool<`${First}${Uppercase}${End}`> : Str
type item = Tool<'aa_bb_cc_dd'>;

2. 判断联合类型

type Tool =
A extends A?[B] extends [A] ? false : true
: never

3. BEM
   BEM是css命名规范

type bemResult = BEM<'guang', ['aaa', 'bbb'], ['warning', 'success']>;
//会转换成
guang__aaa--warning guang__bbb--success

type BEM = `${Ele1}__${Ele2[number]}--${Ele3[number]}`

4. AllCombinations

type Combination =| A| B| `${A}${B}`| `${B}${A}`;
type AllCombinations = 
A extends A? Combination>>: never;
type all = AllCombinations<'A' | 'B' | 'C'>;

type IsEqual = (()=>T extends A ? 1 : 2) extends (()=>T extends B ? 1 : 2) ? true : false

type Test = T extends number ? 1 : 2;
type res = Test<1 | 'a'>;//type res = 1 | 2

type Test = T extends true ? 1 : 2;
type res = Test;//type res = false | true

type Test = T extends true ? 1 : 2;
type res = Test;//type res = 1 | 2

type Test = T extends true ? 1 : 2;
type res = Test;//type res = never

type Parameters any> = T extends (...args: infer P) => any ? P : any;

type ReturnType any> = T extends (...args: any) => infer R ? R : any;

type ConstructorParameters any> = T extends abstract new (...args: infer P) => any ? P : never;

type InstanceType any> = T extends abstract new (...args: any) => infer R ? R : any;

type Partial = {[P in keyof T]?: T[P];
};

type Required = {[P in keyof T]-?: T[P];
};

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

type Pick = {[P in K]: T[P];
};

type Record = {[P in K]: T;
};

type Exclude = T extends U ? never : T;

type Extract = T extends U ? T : never;

type Omit = Pick>;

type Awaited =T extends null | undefined? T : T extends object & { then(onfulfilled: infer F): any }? F extends ((value: infer V, ...args: any) => any)? Awaited: never : T;

type NonNullable = T extends null | undefined ? never : T;

type ThisParameterType = T extends (this: infer U, ...args: any[]) => any ? U : unknown;

type OmitThisParameter = unknown extends ThisParameterType ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T;