模式匹配

function getPropValue<T extends object, Key extends keyof T> (obj: T, key: Key) {
  return obj[key]
}

type Tuple = [number, string]


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

type isTwo<T> = T extends 2 ? true : false;

type res1 = isTwo<1>
type res2 = isTwo<2>

type First<Tuple extends unknown[]> = Tuple extends [infer T, ...infer R] ? T : never;
type res3 = First<[1,2,3]>

type ObjType = { a: number} & { c: boolean }

type MapType<T> = {
  [Key in keyof T]: [T[Key], T[Key], T[Key]]
}


type res4 = MapType<{
  a: 1,
  b: 2
}>

type p = Promise<'guang'>

type getValueType<p> = p extends Promise<infer Value> ? Value : never;

type getValueResult = getValueType<Promise<'guang'>>

数组类型模式匹配

提取数组第一个元素

type arr = [1,2,3]
type GetFirst<Arr extends unknown[]> = Arr extends [infer First, ...unknown[]] ? First : never;

type GetFirstResult = GetFirst<[1,2,3]> // 1

提取最后一个元素

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

type GetLastResult = GetLast<[1,2,3]> // 3

取去掉了最后一个元素的数组

type PopArr <Arr extends unknown[]> = 
  Arr extends [] ? []
   : Arr extends [...infer Rest, unknown] ? Rest : never;
   
type PopResult = PopArr<[]> // []
type PopResult2 = PopArr<[1,2,3]>  // [1,2]

取去掉了第一个元素的数组

type ShiftArr<Arr extends unknown[]> =
  Arr extends [] ? []
   : Arr extends [unknown, ...infer Rest] ? Rest : never;

type ShiftResult = ShiftArr<[]> // []
type ShiftResult2 = ShiftArr<[1,2,3]> // [2,3]

字符串类型的模式匹配

判断字符串是否以某个前缀开头，也是通过模式匹配

type StartsWith<Str extends string, Prefix extends string> = 
    Str extends `${Prefix}${string}` ? true : false;


type StartsWithResult = StartsWith<'guang and dong', 'guang'> // true

type StartsWithResult2 = StartsWith<'guang and dong', 'dong'> // false

字符串可以匹配一个模式类型，提取想要的部分，自然也可以用这些再构成一个新的类型，比如实现字符串替换

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

type ReplaceResult = ReplaceStr<'Guang best friend is ?', '?', 'dongdong'> 
// 'Guang best friend is dongdong'

type ReplaceResult2 = ReplaceStr<'abc', '?', 'dong'> // 'abc'

去掉字符串右侧的空格

type TrimStrRight<Str extends string> = 
    Str extends `${infer Rest}${' ' | '\n' | '\t'}` ? TrimStrRight<Rest> : Str;

type TrimRightResult = TrimStrRight<'guang    '>  // 'guang'

去掉字符串左侧的空格

type TrimStrLeft<Str extends string> = 
Str extends `${' ' | '\n' | '\t'}${infer Rest}` ? TrimStrLeft<Rest> : Str;

type TrimLeftResult = TrimStrLeft<'    dong'> // dong

去掉左右两侧的空格

type TrimStr<Str extends string> = TrimStrRight<TrimStrLeft<Str>>

type TrimResult = TrimStr<' dong   '>   // dong

函数的模式匹配，比如提取参数、返回值的类型

提取函数的参数类型

type GetParameters<Func extends Function> = 
  Func extends (...args: infer Args) => unknown ? Args : never;

type ParameterResult = GetParameters<(name: string, age: number) => string> 
// [name: string, age: number] 是 [string, number]

提取函数的返回值类型

type GetReturnType<Func extends Function> =
  Func extends (...args: any[]) => infer ReturnType ? ReturnType : never;

type ReturnTypeResult = GetReturnType<() => 'dong'> // 'dong'