写一个数组不为空的类型：
ts
type A = [1]
type NotEmpty<Arr extends unknown[]> = Arr extends
[...unknown[], unknown] ? true:false
type Result = NotEmpty<A>
// or
type A = [1]
type NotEmpty<Arr extends unknown[]> = Arr extends
[...infer X, infer Last] ? true:false
type Result = NotEmpty<A>
写一个数组为空的类型：
ts
type A = []
type IsEmptyArray<Arr extends unknown[]> = Arr extends
Arr['length'] extends 0 ? true:false
type Result = IsEmptyArray<A>
写一个数组翻转：
ts
type A = ['ji', 'ni', 'tai', 'mei']
type Reverse<Arr extends unknown[]> =
Arr extends [...infer Rest, infer Last]
? [Last, ...Reverse<Rest>]
: Arr
type Result = Reverse<A>
// Result is ['mei', 'tai', 'ni', 'ji']
获取数组最后一项：
ts
type D = [1,2,3,4]
type LastOfArray<T extends unknown[]> = T extends [...unknown[], infer last] ?
last : never
type E = LastOfArray<D>
获取数组除了最后一项的其他项：
ts
type D = [1,2,3,4]
type LastOfArray<T extends unknown[]> = T extends [...infer Nolast, infer last] ?
Nolast : never
type E = LastOfArray<D>
字符串操作：
ts
// TS 内置好的功能
// 全变成大写
type Uppercase<S extends string> = intrinsic;
// 全变成小写
type Lowercase<S extends string> = intrinsic;
// 首字母大写
type Capitalize<S extends string> = intrinsic;
// 首字母小写
type Uncapitalize<S extends string> = intrinsic;
type A = "ji";
type B = "ni";
type C = "tai";
type D = "mei";
type X = `${A} ${B} ${C} ${D}`;
// ^-- type X = "ji ni tai mei"
// ------------------------------------------- //
// 获取字符串的第一个字符
type A = "ji ni tai mei"
type First<T> = T extends `${infer F}${string}` ? F : never
type Result = First<A>
// ^-- "j"
// 获取字符串最后一个字符？
// 可以使用递归，通过字符串的长度不为 1 来判断；还可以将字符串转成元组，利用元祖获取最后一项。
type LastOfTuple<T extends unknown[]> = T extends [...infer _, infer last]
? last : never
type StringToTuple<S extends string> = S extends `${infer F}${infer R}`
? [F, ...StringToTuple<R>] : []
type LastOfString<S extends string> = LastOfTuple<StringToTuple<S>>
type R = LastOfString<'hello world'>
// 字符串转联合类型
type StringToUnion<S extends string> = S extends `${infer First}${infer Rest}`
? First | StringToUnion<Rest>
: never
type Result = StringToUnion<'hii'>
// type Result = 'h' | 'i'
// 注意：联合类型会自动去重
推断数组元素类型：
ts
type Flatten<Type> = Type extends Array<infer Item> ? Item : Type
type X = Flatten<Array<number>>