Skip to content
On this page

写一个数组不为空的类型:

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>>

Released under the MIT License.