建议做体操之前阅读：

之前在写一个自己的库，深感自身的ts写的太渣，所以决心要好好修炼一下ts，不得不的说，只有掌握了这些姿势，才能在运用中写出更好的类型设计

此外，我很长，你忍一下，实在忍不住，可以mark起来以后再用

忍不住的同学可以直接阅读姿势总结篇

简单

实现pick

实现 TS 内置的 Pick<T, K>，但不可以使用它。

type MyPick<T, K extends keyof T> = {
  [P in K]: T[P]
}
interface Todo {
  title: string
  description: string
  completed: boolean
}

/* 
  A = {
    title: string;
    completed: boolean;
  }
*/
type A = MyPick<Todo, 'title' | 'completed'>

实现 Readonly

type MyReadonly<T> = {
  readonly [P in keyof T]: T[P]
}

元组转换为对象

const tuple = ['tesla', 'model 3', 'model X', 'model Y'] as const

type TupleToObject<T extends readonly (keyof any)[]> = {
  [P in T[number]]:P
}

const result: TupleToObject<typeof tuple> // expected { tesla: 'tesla', 'model 3': 'model 3', 'model X': 'model X', 'model Y': 'model Y'}

注意要加上readonly, 因为 as const 会生成如下的类型：

const tuple: readonly ["tesla", "model 3", "model X", "model Y"]

const 断言文档：www.typescriptlang.org/docs/handbo…

第一个元素

实现一个通用First<T>，它接受一个数组T并返回它的第一个元素的类型。

type First<T extends any[]> = T extends [infer F, ...infer R] ? F : never

元组文档：www.typescriptlang.org/docs/handbo…

infer文档：www.typescriptlang.org/docs/handbo…

获取元组长度

type Length<T extends readonly any[]> = T['length']

元组类型是另一种Array类型，它确切地知道它包含多少元素，以及在特定位置包含哪些类型

扩展 readonly 的表现

数组，元素加上 readonly 为普通形式父集对象属性的 redonly 不影响类型兼容

type A = [string]
type RA = Readonly<A>

type B = string[]
type RB = Readonly<B>

type IsExtends<T, Y> = T extends Y ? true : false

type AExtendsRA = IsExtends<A, RA> //true

type RAExtendsA = IsExtends<RA, A> //false

type BExtendsRA = IsExtends<B, RB> // true

type RBExtendsB = IsExtends<RB, B> // false

type C = {
  name: string
}
type RC = Readonly<C>
type CExtendsRC = IsExtends<C, RC> // true
type RCExtendsC = IsExtends<RC, C> // true

对象只读属性不影响类型兼容：

www.typescriptlang.org/docs/handbo…

stackoverflow.com/questions/5…

数组和元组的只读:

github.com/Microsoft/T…

Exclude

实现内置的Exclude <T，U>

type MyExclude<T, K> = T extends K ? never : T

Awaited

获取 Promise<ExampleType> 中的 ExampleType

type Awaited<T extends Promise<any>> = T extends PromiseLike<infer L> ? L :never

If

example:

type A = If<true, 'a', 'b'>  // expected to be 'a'
type B = If<false, 'a', 'b'> // expected to be 'b'

type If<C extends boolean, T, F> = C extends true ? T : F

Concat

example:

type Result = Concat<[1], [2]> // expected to be [1, 2]

type Concat<T extends any[], U extends any[]> = [...T, ...U]

Includes

example :

type isPillarMen = Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana'], 'Dio'> // expected to be `false`

// 将元组转换一个value为true的对象
type Includes<T extends any[], U> = {
  [K in T[number]]: true
}[U] extends true
  ? true
  : false

type IEqual<T,U> = (<X>()=>X extends T ? 1:2) extends (<X>()=>X extends U ? 1 : 2) ? true :false

type Includes<T extends readonly any[], U> = T extends [infer V, ...infer R]
  ? IEqual<V, U> extends true
    ? true
    : Includes<R, U>
  : false;

中等

获取函数返回类型

不使用 ReturnType 实现 TypeScript 的 ReturnType<T> 范型。

type MyReturnType<T> = T extends (...argv:any[]) => infer T ? T :never

实现 Omit

// one
type MyPick<T, K extends keyof T> = {
  [P in K]: T[P]
}
type MyExclude<T, K> = T extends K ? never : T
type MyOmit<T, K> = MyPick<T, MyExclude<keyof T, K>>


// two
type MyExclude<T, K> = T extends K ? never : T
type MyOmit<T, K> = {
  [P in keyof T as P extends MyExclude<keyof T, K> ? P : never]: T[P]
}

实现 Readonly 2

实现一个通用MyReadonly2<T, K>，它带有两种类型的参数T和K。

K指定应设置为Readonly的T的属性集。如果未提供K，则应使所有属性都变为只读，就像普通的Readonly<T>一样。

type MyReadonly2<T, K=keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P]
} &
  {
    readonly [P in keyof T as P extends K ? P : never]: T[P]
  }

// upgrade
type MyReadonly2<T, K extends keyof T = keyof T> = {
    readonly [P in K]: T[P]
  } & T;

深度 Readonly

实现一个通用的DeepReadonly<T>，它将对象的每个参数及其子对象递归地设为只读。

type IsObjectLiteral<T> = keyof T extends never ? false : true

type DeepReadonly<T> = {
  readonly [P in keyof T]: IsObjectLiteral<T[P]> extends true
    ? DeepReadonly<T[P]>
    : T[P]
}

元组转合集

example:

type Arr = ['1', '2', '3']

const a: TupleToUnion<Arr> // expected to be '1' | '2' | '3'

type TupleToUnion<T extends any[]> = T[number]

可串联构造器

example:

declare const config: Chainable

const result = config
  .option('foo', 123)
  .option('name', 'type-challenges')
  .option('bar', { value: 'Hello World' })
  .get()

// 期望 result 的类型是：
interface Result {
  foo: number
  name: string
  bar: {
    value: string
  }
}

type Chainable<P = {}> = {
  option<K extends string, T>
    (
      key: K extends keyof P ? never : K,
      value: T
    ): Chainable<P & {[key in K]: T}>
  get(): P
}

最后一个元素

实现一个通用Last<T>，它接受一个数组T并返回其最后一个元素的类型。

example:

type arr1 = ['a', 'b', 'c']
type arr2 = [3, 2, 1]

type tail1 = Last<arr1> // expected to be 'c'
type tail2 = Last<arr2> // expected to be 1

type Last<T extends any[]> = T extends [...any[], infer Latest] ? Latest : never

出堆

实现一个通用Pop<T>，它接受一个数组T并返回一个没有最后一个元素的数组。 example:

type arr1 = ['a', 'b', 'c', 'd']
type arr2 = [3, 2, 1]

type re1 = Pop<arr1> // expected to be ['a', 'b', 'c']
type re2 = Pop<arr2> // expected to be [3, 2]

type Pop<T extends any[]> = T extends [... infer R, infer L] ? R :never

Promise.all

实现PromiseAll，它接受PromiseLike对象数组，返回值应为Promise<T>，其中T是解析的结果数组。

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise<string>((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

// expected to be `Promise<[number, number, string]>`
const p = Promise.all([promise1, promise2, promise3] as const)

declare function PromiseAll<T extends readonly unknown[]>(
  args: readonly [...T]
): Promise<{ [P in keyof T]: T[P] extends Promise<infer R> ? R : T[P] }>

参考可变元组：文档 PR

Type Lookup

根据其属性在并集中查找类型。期望LookUp<Dog | Cat, 'dog'>获得Dog，LookUp<Dog | Cat, 'cat'>获得Cat。

interface Cat {
  type: 'cat'
  breeds: 'Abyssinian' | 'Shorthair' | 'Curl' | 'Bengal'
}

interface Dog {
  type: 'dog'
  breeds: 'Hound' | 'Brittany' | 'Bulldog' | 'Boxer'
  color: 'brown' | 'white' | 'black'
}

type MyDog = LookUp<Cat | Dog, 'dog'> // expected to be `Dog`

type LookUp<U, T> = U extends { type: T } ? U : never

Trim Left

删除开始的空格 example:

type trimed = TrimLeft<'  Hello World  '> // expected to be 'Hello World  '

type TWhiteSpace = ' ' | '\n' | '\t'
type TrimLeft<S extends string> = S extends `${TWhiteSpace}${infer R}`
  ? TrimLeft<R>
  : S

Trim

去除两侧空格 example:

type trimed = Trim<'  Hello World  '> // expected to be 'Hello World'

type TWhiteSpace = ' ' | '\n' | '\t'
type TrimLeft<S extends string> = S extends `${TWhiteSpace}${infer R}`
  ? TrimLeft<R>
  : S
type TrimRight<S extends string> = S extends `${infer R}${TWhiteSpace}`
  ? TrimRight<R>
  : S

type Trim<T extends string> = TrimRight<TrimLeft<T>>

关于模板字符串和infer的可以查看这些资料：

infer: www.typescriptlang.org/docs/handbo…

模板字符串的支持：github.com/microsoft/T…

Capitalize

实现 Capitalize 将第一个字母转换为大写

example:

type capitalized = Capitalize<'hello world'> // expected to be 'Hello world'

type Capitalize<S extends string> = S extends `${infer L}${infer R}`
  ? `${Uppercase<L>}${R}`
  : ''

Replace

example:

type replaced = Replace<'types are fun!', 'fun', 'awesome'> // expected to be 'types are awesome!'

type Replace<
  S extends string,
  From extends string,
  To extends string
> = From extends ''
  ? S
  : S extends `${infer L}${From}${infer R}`
  ? `${L}${To}${R}`
  : S

ReplaceAll

example:

type replaced = ReplaceAll<'t y p e s', ' ', ''> // expected to be 'types'

type ReplaceAll<
  S extends string,
  From extends string,
  To extends string
> = From extends ''
  ? S
  : S extends `${infer L}${From}${infer R}`
  ? `${ReplaceAll<L, From, To>}${To}${ReplaceAll<R, From, To>}`
  : S

追加参数

example:

type Fn = (a: number, b: string) => number

type Result = AppendArgument<Fn, boolean> 
// 期望是 (a: number, b: string, x: boolean) => number

type AppendArgument<Fn extends (...s: any[]) => any, A> = Fn extends (
  ...s: infer T
) => infer R
  ? (...s: [...T, A]) => R
  : never

Permutation

实现将联合类型转换为包含联合排列的数组的排列类型

example:

type perm = Permutation<'A' | 'B' | 'C'>; // ['A', 'B', 'C'] | ['A', 'C', 'B'] | ['B', 'A', 'C'] | ['B', 'C', 'A'] | ['C', 'A', 'B'] | ['C', 'B', 'A']

//分布式 确定 第一个元素，再把第一个元素除去，递归确定剩余元素
type Permutation<T, P = T> = [T] extends [never]
  ? []
  : T extends any
  ? [T, ...Permutation<Exclude<P, T>>]
  : never

Length of String

计算字符串的长度

type LengthOfString<S extends string, T extends any[] = []> = S extends `${infer L}${infer R}`
  ? LengthOfString<R, [...T, L]>
  : T['length']

Flatten

example:

type flatten = Flatten<[1, 2, [3, 4], [[[5]]]]> // [1, 2, 3, 4, 5]

type Flatten<T extends any[]> = T extends [infer First, ...infer Rest]
  ? [...(First extends any[] ? Flatten<First> : [First]), ...Flatten<Rest>]
  : T

Append to object

实现一种向接口添加新字段的类型

example:

type Test = { id: '1' }
type Result = AppendToObject<Test, 'value', 4> // expected to be { id: '1', value: 4 }

type Merge<T> = {
  [P in keyof T]: T[P]
}

type AppendToObject<T, U extends string, V> = Merge<
  { [P in keyof T]: T[P] } & { [P in U]: V }
>

需要注意一下这种情况：

交集相等问题

type Equal<T, D> = (<S>() => S extends T ? 1 : 2) extends <S>() => S extends D
  ? 1
  : 2
  ? true
  : false

type A = {
  name: string
  age: number
}
type B = {
  name: string
}
type Merge<T> = {
  [P in keyof T]: T[P]
}

type IsEqual1 = Equal<A, B & { age: number }> //false
type IsEqual2 = Equal<A, Merge<B & { age: number }>> // true

Absolute

实现 Absolute。接收字符串、数字或 bigint 的类型。输出应该是一个正数字符串

example:

type Test = -100;
type Result = Absolute<Test>; // expected to be "100"

type Number = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
type Absolute<T extends number | string | bigint> =
  `${T}` extends `${infer First}${infer Reset}`
    ? `${First}` extends `${Number}`
      ? `${First}${Absolute<Reset>}`
      : `${Absolute<Reset>}`
    : ''

String to Union

example:

type Test = '123';
type Result = StringToUnion<Test>; // expected to be "1" | "2" | "3"

type StringToUnion<T extends string> = T extends `${infer First}${infer Reset}`
  ? First | StringToUnion<Reset>
  : never

Merge

将两个类型合并为一个新类型。相同的key的情况下，第二个覆盖第一个

type IntersectionToObj<T> = {
  [P in keyof T]:T[P]
}

type Merge<F, S> = IntersectionToObj<Omit<F, keyof S> & S>

CamelCase

example: for-bar-baz -> forBarBaz

type ConcatDash<S extends string> = `-${S}`
type CamelCase<S extends string> = S extends `${infer L}-${infer M}${infer R}`
  ? M extends '-'
    ? `${L}-${CamelCase<ConcatDash<R>>}`
    : M extends Uppercase<M>
    ? `${L}-${M}${CamelCase<R>}`
    : `${L}${Uppercase<M>}${CamelCase<R>}`
  : S

KebabCase

example: FooBarBaz -> for-bar-baz

type StringToUnion<T extends string> = T extends `${infer First}${infer Reset}`
  ? First | StringToUnion<Reset>
  : never

type UpperCases = StringToUnion<'ABCDEFGH'> | StringToUnion<'IJKLMNOPQRSTUVXYZ'>
type Split<S extends string> = S extends `${infer L}${infer R}`
  ? L extends UpperCases
    ? L extends Uppercase<L>
      ? `-${Lowercase<L>}${Split<R>}`
      : `${L}${Split<R>}`
    : `${L}${Split<R>}`
  : S
type DelFirst<T extends string, U extends string> = T extends `-${string}`
  ? U
  : U extends `-${infer R}`
  ? R
  : U

type KebabCase<T extends string> = DelFirst<T, Split<T>>

Diff

比较两个对象类型的差别

type Merge<T> = {
  [P in keyof T]: T[P]
}
type Diff<O, O1> = Merge<
  | {
      [P in Exclude<keyof O, keyof O1>]: O[P]
    } &
      {
        [P in Exclude<keyof O1, keyof O>]: O1[P]
      }
>

AnyOf

接受Array，如果Array中的任何元素为true则返回true。否则返回false example:

type Sample1 = AnyOf<[1, "", false, [], {}]>; // expected to be true.
type Sample2 = AnyOf<[0, "", false, [], {}]>; // expected to be false.

type FalseUnion = false | '' | 0 | Record<string | number, never> | []
type AnyOf<T extends readonly any[]> = T extends [infer First, ...infer Reset]
  ? First extends FalseUnion
    ? AnyOf<Reset>
    : true
  : false```

这里需要注意的是 {} 是相对大的集合

type A = { name: string } extends {} ? true : false // true
type C = { name: string } extends Record<string | number, never> ? true : false // false

IsNever

example:

type A = IsNever<never>  // expected to be true
type B = IsNever<undefined> // expected to be false
type C = IsNever<null> // expected to be false
type D = IsNever<[]> // expected to be false
type E = IsNever<number> // expected to be false

type IsNever<T> = [T] extends [never] ? true : false

never是最小的集合,只有never能赋值给never 文档

IsUnion

example:

type case1 = IsUnion<string>  // false
type case2 = IsUnion<string|number>  // true
type case3 = IsUnion<[string|number]>  // false

第一种方法

type IsUnion<T> = (T extends any ? (arg: T) => void : never) extends (
  arg: infer U
) => void
  ? [T] extends [U]
    ? false
    : true
  : never

利用联合类型逆变的特性，如果是联合类型，则发生逆变为交集类型

第二种方法

type IsUnion<T , U = T> = T extends U? 
  [U] extends [T]?false:true
  :never;

利用分配式的特性如果 T 为联合类型，则发生分配式，此时 T 为联合类型其中的一个子类型，U 为 T

ReplaceKeys

实现一个类型ReplaceKeys，替换联合类型中的键，如果某些类型没有这个键，就跳过替换，类型有三个参数。 example:

type NodeA = {
  type: 'A'
  name: string
  flag: number
}

type NodeB = {
  type: 'B'
  id: number
  flag: number
}

type NodeC = {
  type: 'C'
  name: string
  flag: number
}


type Nodes = NodeA | NodeB | NodeC

type ReplacedNodes = ReplaceKeys<Nodes, 'name' | 'flag', {name: number, flag: string}> // {type: 'A', name: number, flag: string} | {type: 'B', id: number, flag: string} | {type: 'C', name: number, flag: string} // would replace name from string to number, replace flag from number to string.

type ReplacedNotExistKeys = ReplaceKeys<Nodes, 'name', {aa: number}> // {type: 'A', name: never, flag: number} | NodeB | {type: 'C', name: never, flag: number} // would replace name to never

type ReplaceKeys<U, T extends string, Y> = {
  [K in keyof U]: K extends T ? (K extends keyof Y ? Y[K] : never) : U[K]
}

这里需要注意的是映射类型当接收联合类型时也是分布式的

type NodeA = {
  type: 'A'
  name: string
  flag: number
}

type NodeB = {
  type: 'B'
  id: number
  flag: number
}

type NodeC = {
  type: 'C'
  name: string
  flag: number
}

type Nodes = NodeA | NodeB | NodeC
type Map<T> = {
  [P in keyof T]: T[P]
}
// Map<NodeA> | Map<NodeB> | Map<NodeC>
type A = Map<Nodes>

Remove Index Signature

实现RemoveIndexSignature<T>，从对象类型中排除索引签名。 example：

type Foo = {
  [key: string]: any;
  foo(): void;
}
type A = RemoveIndexSignature<Foo>  // expected { foo(): void }

// An index signature parameter type be either 'string' or 'number'. 
type RemoveIndexSignature<T> = {
  [K in keyof T as string extends K
    ? never
    : number extends K
    ? never
    : K]: T[K]
}

参考：www.typescriptlang.org/docs/handbo…

百分比解析器

example:

type PString1 = ''
type PString2 = '+85%'
type PString3 = '-85%'
type PString4 = '85%'
type PString5 = '85'

type R1 = PercentageParser<PString1>  // expected ['', '', '']
type R2 = PercentageParser<PString2>  // expected ["+", "85", "%"]
type R3 = PercentageParser<PString3>  // expected ["-", "85", "%"]
type R4 = PercentageParser<PString4>  // expected ["", "85", "%"]
type R5 = PercentageParser<PString5>  // expected ["", "85", ""]

type Num = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
type Operation = '+' | '-'
type PercentageParser<T, U extends string[] = [], N = 0> = N extends 0
  ? T extends `${infer L}${infer R}`
    ? L extends Operation
      ? PercentageParser<R, [L], 1>
      : PercentageParser<T, [''], 1>
    : PercentageParser<T, ['', ''], 2>
  : N extends 1
  ? T extends `${infer L}${infer R}`
    ? L extends Num
      ? PercentageParser<R, [U[0], `${U[1] extends string ? U[1] : ''}${L}`], 1>
      : PercentageParser<T, [U[0], U[1] extends string ? U[1] : ''], 2>
    : PercentageParser<T, [U[0], U[1] extends string ? U[1] : ''], 2>
  : N extends 2
  ? T extends `${infer L}`
    ? L extends '%'
      ? [U[0], U[1], '%']
      : [U[0], U[1], '']
    : [U[0], U[1], '%']
  : never

Drop Char

从字符串中删除指定的字符。

example:

type Butterfly = DropChar<' b u t t e r f l y ! ', ' '> // 'butterfly!'

type EqualType<T, R> = [T] extends [R] ? ([R] extends [T] ? true : false) : false
type DropChar<
  S extends string,
  C extends string
> = S extends `${infer L}${infer R}`
  ? `${EqualType<L, C> extends true ? '' : L}${DropChar<R, C>}`
  : ''

// Display exceeds recursion limit
// type DropChar<S extends string, C> = S extends `${infer L}${infer R}`
//   ? L extends C
//     ? C extends L
//       ? DropChar<R, C>
//       : `${L}${DropChar<R, C>}`
//     : `${L}${DropChar<R, C>}`
//   : ''

MinusOne

给定一个数字(总是正数)作为类型。返回减少1的数字。 example:

type Zero = MinusOne<1> // 0
type FiftyFour = MinusOne<55> // 54

type Make10Array<T extends any[]> = [
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T
]
type Make1Array<T, L extends any[] = []> = `${L['length']}` extends T
  ? L
  : Make1Array<T, [...L, 1]>
  
type AddEqualArrayLength<
  T extends string,
  L extends any[] = []
> = T extends `${infer U}${infer R}`
  ? AddEqualArrayLength<R, [...Make10Array<L>, ...Make1Array<U>]>
  : L

type Pop<T extends any[]> = T extends [...infer F, number] ? F : never
type MinusOne<T extends number> = Pop<AddEqualArrayLength<`${T}`>>['length']

PickByType

example:

type OnlyBoolean = PickByType<{
  name: string
  count: number
  isReadonly: boolean
  isEnable: boolean
}, boolean> // { isReadonly: boolean; isEnable: boolean; }

type EqualType<T, R> = [T] extends [R]
  ? [R] extends [T]
    ? true
    : false
  : false

type PickByType<T, U> = {
  [P in keyof T as EqualType<T[P], U> extends true ? P : never]: T[P]
}

StartsWith

example:

type a = StartsWith<'abc', 'ac'> // expected to be false
type b = StartsWith<'abc', 'ab'> // expected to be true
type c = StartsWith<'abc', 'abcd'> // expected to be false

type StartsWith<T extends string, U extends string> = T extends `${U}${string}` ? true : false

EndsWith

实现EndsWith<T, U>，它接受两个精确的字符串类型并返回T是否以U结尾

type EndsWith<T extends string, U extends string> = T extends `${string}${U}` ? true : false

PartialByKeys

指定对象类型中 keys 为可选

example:

interface User {
  name: string
  age: number
  address: string
}

type UserPartialName = PartialByKeys<User, 'name'> // { name?:string; age:number; address:string }

type IntersectionToObj<T> = {
  [K in keyof T]: T[K]
}
type PartialByKeys<T , K = any> = IntersectionToObj<{
  [P in keyof T as P extends K ? P : never]?: T[P]
} & {
  [P in Exclude<keyof T, K>]: T[P]
}>

RequiredByKeys

实现一个泛型RequiredByKeys<T, K>，它接受两个类型参数T和K。 K 指定应设置为必需的 T 的属性集。当未提供 K 时，它应该像正常的 Required<T> 一样要求所有属性。

example:

interface User {
  name?: string
  age?: number
  address?: string
}

type UserPartialName = RequiredByKeys<User, 'name'> // { name: string; age?: number; address?: string }

type IntersectionToObj<T> = {
  [K in keyof T]: T[K]
}
type RequiredByKeys<T , K = any> = IntersectionToObj<{
  [P in keyof T as P extends K ? P : never]-?: T[P]
} & {
  [P in Exclude<keyof T, K>]?: T[P]
}>

Mutable

实现泛型Mutable<T>，这使得T中的所有属性都是可变的(不是只读的)。

example:

interface Todo {
  readonly title: string
  readonly description: string
  readonly completed: boolean
}

type MutableTodo = Mutable<T> // { title: string; description: string; completed: boolean; }

type Mutable<T> = {
  -readonly [K in keyof T]:T[K]
}

困难

简单的 Vue 类型

实现类似Vue的类型支持的简化版本。

通过提供函数名称SimpleVue（类似于Vue.extend或defineComponent），它应该正确地推断出计算和方法内部的this类型。

在此挑战中，我们假设SimpleVue接受带有data，computed和methods字段的Object作为唯一参数，

-data是一个简单的函数，它返回一个公开上下文this的对象，但是您无法访问data中的数据本身或其他计算机值或方法。

-computed是将上下文作为this的函数的对象，进行一些计算并返回结果。计算结果应作为简单的返回值而不是函数显示给上下文。

-methods是函数的对象，其上下文也与this相同。方法可以访问data，computed以及其他methods公开的字段。 computed与methods的不同之处在于按原样公开的功能。

SimpleVue的返回值类型可以是任意的。

// 这里的推导很神奇 从 any 推导除了 string
type A = Record<string, any>

interface Options<D, C extends A, M> {
  data: (this: void) => D
  computed: C & ThisType<D & C>
  methods: M & ThisType<M & { [P in keyof C]: ReturnType<C[P]> }>
}
declare function SimpleVue<D, C extends A, M>(options: Options<D, C, M>): any

// 另外一种直观一些的写法
type ComputedReturnType<T> = T extends Record<string, () => any>
  ? {
      [P in keyof T]: ReturnType<T[P]>
    }
  : never

interface Options<D, C, M> {
  data: (this: void) => D
  computed: C & ThisType<D>
  methods: M & ThisType<M & ComputedReturnType<C>>
}
declare function SimpleVue<D, C, M>(options: Options<D, C, M>): any

参考：函数泛型 ThisType

科里化 1

example:

const add = (a: number, b: number) => a + b
const three = add(1, 2)

const curriedAdd = Currying(add)
const five = curriedAdd(2)(3)

type Curr<A extends any[], R> = A extends [...infer F, infer L]
  ? Curr<F, (x: L) => R>
  : R

declare function Currying<T>(
  fn: T
): T extends (...argv: infer A) => infer R ? Curr<A, R> : never

Union to Intersection

example:

type I = Union2Intersection<'foo' | 42 | true> // expected to be 'foo' & 42 & true

type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
  x: infer R
) => void
  ? R
  : never

Get Required

实现高级util类型GetRequired<T>，该类型保留所有必填字段 example:

type I = GetRequired<{ foo: number, bar?: string }> // expected to be { foo: number }

type IfEquals<X, Y> = [X] extends [Y] ? ([Y] extends [X] ? true : false) : false
type GetRequired<T> = {
  [P in keyof T as IfEquals<
    { [O in P]: T[P] },
    { [O in P]-?: T[P] }
  > extends true
    ? P
    : never]: T[P]
}

// 基于
type F = {
  name?: string
}
type R = {
  name: string
}

// 加上 [] 是为了防止联合类型进行分配模式
type IfEquals<X, Y> = [X] extends [Y] ? ([Y] extends [X] ? true : false) : false
type G = IfEquals<F, R>    // false

Get Optional

实现高级util类型GetOptional<T>，该类型保留所有可选字段

type I = GetOptional<{ foo: number, bar?: string }> // expected to be { bar?: string }

// one 
type IfEquals<X, Y> = [X] extends [Y] ? ([Y] extends [X] ? true : false) : false
type GetOptional<T> = {
  [P in keyof T as IfEquals<
    { [O in P]: T[P] },
    { [O in P]-?: T[P] }
  > extends true
    ? never
    : P]?: T[P]
}

// two
type FilterOptionalKey<T, K extends keyof T> = T extends {
  [k in K]-?: T[k]
}
  ? never
  : K

type GetOptional<T> = {
  [K in keyof T as FilterOptionalKey<T, K>]: T[K]
}

第二种方法基于以下思想

type hasA = {
  name?: string
  age: number
}
type A = {
  name: string
  age: number
}
type B = {
  name: string
}

type C = hasA extends B ? true : false //false
type D = A extends B ? true : false //true

当属性可选时，为较大集合

type hasA = {
  name?: string
  age: number
}
type A = {
  name: string
  age: number
}

type C = hasA extends A ? true : false //false
type D = A extends hasA ? true : false //true

Required Keys

实现高级util类型RequiredKeys<T>，该类型将所有必需的键都选择为一个并集。 example:

type Result = RequiredKeys<{ foo: number; bar?: string }>;
// expected to be “foo”

type RequiredKeys<T> = keyof {
  [P in keyof T as T[P] extends Required<T>[P] ? P : never] : T[P]
}

Optional Keys

实现高级util类型OptionalKeys<T>，该类型将所有可选键合并为一个并集。

// one
type OptionalKeys<T, K = keyof T> = K extends keyof T
  ? T extends Required<Pick<T, K>>
    ? never
    : K
  : never

利用分配模式，逐一判断T 的key是否为可选

//two 
type DropUndefined<T> = T extends undefined ? never : T
type OptionalKeys<T> = DropUndefined<
  {
    [P in keyof T]: {} extends Pick<T, P> ? P : never
  }[keyof T]
>

这里要注意的是可选属性在映射之后会存在一个undefined的union

type Map<T> = {
  [P in keyof T]: T[P]
}
/* 
  type C = {
    a: number;
    b?: string | undefined;
  }
*/
type C = Map<{ a: number; b?: string }>

Capitalize Words

实现CapitalizeWords<T>，它将字符串中每个单词的第一个字母转换为大写，其余的保持原样。 example:

type capitalized = CapitalizeWords<'hello world, my friends'> // expected to be 'Hello World, My Friends'

type FirstUppercase<T> = T extends `${infer L}${infer R}`
  ? `${Uppercase<L>}${R}`
  : T
type SpiltCode = ' ' | '.' | ','

type Recursion<S extends string> = S extends `${infer M}${infer L}${infer R}`
  ? M extends SpiltCode
    ? `${M}${Uppercase<L>}${Recursion<R>}`
    : `${M}${Recursion<`${L}${R}`>}`
  : S

type CapitalizeWords<T extends string> = Recursion<FirstUppercase<T>>

CamelCase

实现 CamelCase<T> 将snake_case 字符串转换为camelCase。

example:

type camelCase1 = CamelCase<'hello_world_with_types'> // expected to be 'helloWorldWithTypes'
type camelCase2 = CamelCase<'HELLO_WORLD_WITH_TYPES'> // expected to be same as previous one

type CamelCase<S extends string> = S extends `${infer L}_${infer R}${infer I}`
  ? `${Lowercase<L>}${Uppercase<R>}${CamelCase<I>}`
  : Lowercase<S>

C-printf Parser

C语言中有一个函数:printf。这个函数允许我们打印带有格式化的内容。像这样

printf("The result is %d.", 42);

这个问题要求您解析输入字符串并提取格式占位符，如%d和%f。例如，如果输入字符串是"the result is %d."，则解析的结果是一个元组['dec']。

这是映射

type ControlsMap = {
  c: 'char',
  s: 'string',
  d: 'dec',
  o: 'oct',
  h: 'hex',
  f: 'float',
  p: 'pointer',
}

type ParsePrintFormat<
  S extends string,
  T extends any[] = []
> = S extends `${string}%${infer M}${infer R}`
  ? M extends keyof ControlsMap
    ? ParsePrintFormat<R, [...T, ControlsMap[M]]>
    : ParsePrintFormat<R, [...T]>
  : T

Vue Basic Props

这个挑战从Simple Vue开始，你应该先完成那个，然后根据它修改你的代码来开始这个挑战。

type Constructor<T> = T extends (...args: any) => infer R
  ? R
  : T extends new (...args: any) => infer R2
  ? R2
  : any

type PropType<T> = T extends Array<any>
  ? Constructor<T[number]>
  : Constructor<T>

type Prop<P> = {
  [K in keyof P]: P[K] extends {}
    ? 'type' extends keyof P[K]
      ? PropType<P[K]['type']>
      : PropType<P[K]>
    : PropType<P[K]>
}

type ComputedReturnType<T> = T extends Record<string, () => any>
  ? {
      [P in keyof T]: ReturnType<T[P]>
    }
  : never

interface Options<P, D, C, M> {
  props: P
  data: (this: Prop<P>) => D
  computed: C & ThisType<D>
  methods: M & ThisType<M & ComputedReturnType<C> & Prop<P>>
}
declare function VueBasicProps<P, D, C, M>(options: Options<P, D, C, M>): any

这些要注意的是 class 在直接使用时，ts会自动推断为 typeof class

class ClassA {}

function test<T>(s: T) {
  return s
}
// const r: typeof ClassA
const r = test(ClassA)

再结合这个结论

/**
 * 定义一个类
 */
class People {
  name: number;
  age: number;
  constructor() {}
}

// p1可以正常赋值
const p1: People = new People();
// 等号后面的People报错，类型“typeof People”缺少类型“People”中的以下属性: name, age
const p2: People = People;

// p3报错，类型 "People" 中缺少属性 "prototype"，但类型 "typeof People" 中需要该属性
const p3: typeof People = new People();
// p4可以正常赋值
const p4: typeof People = People;

当把类直接作为类型时，该类型约束的是该类型必须是类的实例
当把typeof 类作为类型时，约束的满足该类的类型

所以上边使用的是

T extends new (...args: any) => infer R2

IsAny

编写一个实用程序类型IsAny<T>，它接受输入类型T。如果T是any，返回true，否则返回false

// one
type IsAny<T> =  unknown extends T
    ? [T] extends [string]
      ? true
      : false
    : false

unkonw 只能赋值给 unkonw 或者 any
any 除了可以赋值给 unkonw 外还可以赋值给其它值(除了never) 参考:www.typescriptlang.org/docs/handbo…

// two
ref: https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
type IsAny<T> = 0 extends (1 & T) ? true : false;

any 是所以类型的父类和子类(除了 never)，所以当 1 & any 是为 any

Typed Get

实现ts版，类似 lodash 中get的功能在此挑战中不需要访问数组。 example:

type Data = {
  foo: {
    bar: {
      value: 'foobar',
      count: 6,
    },
    included: true,
  },
  hello: 'world'
}
  
type A = Get<Data, 'hello'> // 'world'
type B = Get<Data, 'foo.bar.count'> // 6
type C = Get<Data, 'foo.bar'> // { value: 'foobar', count: 6 }

type Get<T, K> = K extends `${infer L}.${infer R}`
  ? L extends keyof T
    ? Get<T[L], R>
    : never
  : K extends keyof T
  ? T[K]
  : never

String to Number

将字符串文字转换为数字

type Map = {
  '0': []
  '1': [1]
  '2': [...Map['1'], 1]
  '3': [...Map['2'], 1]
  '4': [...Map['3'], 1]
  '5': [...Map['4'], 1]
  '6': [...Map['5'], 1]
  '7': [...Map['6'], 1]
  '8': [...Map['7'], 1]
  '9': [...Map['8'], 1]
}
type Make10Array<T extends any[]> = [
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T,
  ...T
]
type ToNumber<
  S extends string,
  L extends any[] = []
> = S extends `${infer F}${infer R}`
  ? ToNumber<R, [...Make10Array<L>, ...(F extends keyof Map ? Map[F] : never)]>
  : L['length']

Tuple Filter

实现一个类型FilterOut<T, F>，它从元组T中过滤出给定的类型F

example:

type Filtered = FilterOut<[1, 2, null, 3], null> // [1, 2, 3]

type FilterOut<T extends any[], F, Stash extends any[] = []> = T extends [
  infer L,
  ...infer R
]
  ? [L] extends [F]
    ? FilterOut<R, F, Stash>
    : FilterOut<R, F, [...Stash, L]>
  : Stash

Tuple to Enum Object

example:

Enum<["macOS", "Windows", "Linux"]>
// -> { readonly MacOS: "macOS", readonly Windows: "Windows", readonly Linux: "Linux" }

Enum<["macOS", "Windows", "Linux"], true>
// -> { readonly MacOS: 0, readonly Windows: 1, readonly Linux: 2 }

type IndexOf<T, P, S extends any[] = []> = T extends readonly [
  infer F,
  ...infer R
]
  ? P extends F
    ? S['length']
    : IndexOf<R, P, [...S, 1]>
  : S['length']

type Enum<T extends readonly string[], N extends boolean = false> = {
  readonly [P in T[number] as Capitalize<P>]: N extends true ? IndexOf<T, P> : P
}

printf

example:

type FormatCase1 = Format<"%sabc"> // FormatCase1 : string => string
type FormatCase2 = Format<"%s%dabc"> // FormatCase2 : string => number => string
type FormatCase3 = Format<"sdabc"> // FormatCase3 :  string
type FormatCase4 = Format<"sd%abc"> // FormatCase4 :  string

// 可以再拓展
type MapDict = {
  s: string
  d: number
}

type Format<T extends string> = T extends `${string}%${infer M}${infer R}`
  ? M extends keyof MapDict
    ? (x: MapDict[M]) => Format<R>
    : Format<R>
  : string

Deep object to unique

创建一个类型，该类型接受一个对象，并使其及其中所有深度嵌套的对象唯一，同时保留所有对象的字符串和数字键，以及这些键上的所有属性的值。

example:

import { Equal } from "@type-challenges/utils"

type Foo = { foo: 2; bar: { 0: 1 }; baz: { 0: 1 } }

type UniqFoo = DeepObjectToUniq<Foo>

declare let foo: Foo
declare let uniqFoo: UniqFoo

uniqFoo = foo // ok
foo = uniqFoo // ok

type T0 = Equal<UniqFoo, Foo> // false
type T1 = UniqFoo["foo"] // 2
type T2 = Equal<UniqFoo["bar"], UniqFoo["baz"]> // false
type T3 = UniqFoo["bar"][0] // 1
type T4 = Equal<keyof Foo & string, keyof UniqFoo & string> // true

type Merge<T> = {
  [P in keyof T]: T[P]
}
type DeepObjectToUniq<O extends object> = {
  [P in keyof O]: O[P] extends object
    ? DeepObjectToUniq<Merge<O[P] & { _xxx?: [O, P] }>>
    : O[P]
}

Length of String 2

实现一个类型 LengthOfString<S> 来计算模板字符串的长度该类型必须支持几百个字符长的字符串(通常字符串长度的递归计算受到TS中递归函数调用深度的限制，也就是说，它支持最多45个字符长的字符串)。

example:

type T0 = LengthOfString<"foo"> // 3

type LengthOfString<S extends string, T extends any[] = []> = S extends ''
  ? T['length']
  : S extends `${infer L}${infer Q}${infer W}${infer E}${infer Y}${infer U}${infer I}${infer O}${infer P}${infer R}`
  ? LengthOfString<R, [...T, L, Q, W, E, Y, U, I, O, P]>
  : S extends `${infer L}${infer R}`
  ? LengthOfString<R, [...T, L]>
  : T['length']

这里的实现思路很简单，每次递归多匹配一些好了，

Union to Tuple

实现一个类型，UnionToTuple，它将联合转换为元组。

因为联合类型是无序的，但是元组是有序的，因此在这个挑战中，输出任何顺序的元素都是可以的

example:

UnionToTuple<1>           // [1], and correct
UnionToTuple<'any' | 'a'> // ['any','a'], and correct

它不应该是一个元组联合

UnionToTuple<'any' | 'a'> // ['a','any'], and correct

联合可能会崩溃，这意味着某些类型可以吸收（或被其他类型吸收）并且无法阻止这种吸收。请参阅以下示例：

Equal<UnionToTuple<any | 'a'>,       UnionToTuple<any>>         // will always be a true
Equal<UnionToTuple<unknown | 'a'>,   UnionToTuple<unknown>>     // will always be a true
Equal<UnionToTuple<never | 'a'>,     UnionToTuple<'a'>>         // will always be a true
Equal<UnionToTuple<'a' | 'a' | 'a'>, UnionToTuple<'a'>>         // will always be a true

answers:

// https://github.com/type-challenges/type-challenges/issues/737
type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
  x: infer U
) => any
  ? U
  : never

// get last Union: LastUnion<1|2> => 2
// ((x: A) => any) & ((x: B) => any) is overloaded function then Conditional types are inferred only from the last overload
// https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#type-inference-in-conditional-types
type LastUnion<T> = UnionToIntersection<
  T extends any ? (x: T) => any : never
> extends (x: infer L) => any
  ? L
  : never

type UnionToTuple<T, Last = LastUnion<T>> = [T] extends [never]
  ? []
  : [...UnionToTuple<Exclude<T, Last>>, Last]

比较难理解的是 LastUnion

这里先把把每个联合类型的元素转换为了一个函数

(x: T) => any | (x: T) => any | (x: T) => any
利用分配模式，和函数的逆变性，把联合类型转换为交集类型

(x: T) => any & (x: T) => any & (x: T) => any
再利用多签名类型(例如函数重载)进行条件推断时，将只从最后一个签名进行推断

参考文档: www.typescriptlang.org/docs/handbo…

String Join

创建一个字符串连接实用程序 example:

const hyphenJoiner = join('-')
const result = hyphenJoiner('a', 'b', 'c'); // = 'a-b-c'

// 或者
join('#')('a', 'b', 'c') // = 'a#b#c'

//当我们传递一个空分隔符(即")来连接时，应该将字符串原样连接起来，即
join('')('a', 'b', 'c') // = 'abc'

//当只传递一个项时，应该返回原始项(不添加任何分隔符)
join('-')('a') // = 'a'

type JoinStr<
  J extends string,
  T extends string[],
  S extends string = ''
> = T extends [infer F, ...infer R]
  ? F extends string
    ? R extends string[]
      ? S extends ''
        ? JoinStr<J, R, `${F}`>
        : JoinStr<J, R, `${S}${J}${F}`>
      : `${S}${J}${F}`
    : S
  : S
declare function join<J extends string>(
  delimiter: J
): <T extends string[]>(...parts: T) => JoinStr<J, T>

Deepick

实现一个类型DeepPick，它扩展了实用程序类型Pick

exapmle:


type obj = {
  name: 'hoge', 
  age: 20,
  friend: {
    name: 'fuga',
    age: 30,
    family: {
      name: 'baz',  
      age: 1 
    }
  }
}

type T1 = DeepPick<obj, 'name'>   // { name : 'hoge' }
type T2 = DeepPick<obj, 'name' | 'friend.name'>  // { name : 'hoge' } & { friend: { name: 'fuga' }}
type T3 = DeepPick<obj, 'name' | 'friend.name' |  'friend.family.name'>  // { name : 'hoge' } &  { friend: { name: 'fuga' }} & { friend: { family: { name: 'baz' }}}

type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
  x: infer R
) => any
  ? R
  : never

type GetValue<T, K extends string> = K extends keyof T
  ? Pick<T, K>
  : K extends `${infer L}.${infer R}`
  ? {
      [P in L]: P extends keyof T ? GetValue<T[P], R> : unknown
    }
  : unknown
type DeepPick<T, K extends string> = UnionToIntersection<GetValue<T, K>>

Pinia

创建一个类型级别的函数，其类型与Pinia库类似。实际上你不需要实现函数，只需要添加类型。

这个函数只接收一个对象类型的参数。该对象包含4个属性

id - 只是一个字符串(必需)
state - 一个函数，返回一个对象作为store的状态(必需的)
getters - 一个具有类似于Vue的计算值或Vuex的getter方法的对象，详细信息如下(可选)
actions - 一个带有方法的对象，这些方法可以执行副作用和改变状态，详细信息如下(可选)

Getters

当你这样定义一个 store

const store = defineStore({
  // ...other required fields
  getters: {
    getSomething() {
      return 'xxx'
    }
  }
})

你可以这样使用它

store.getSomething

不可以这样使用

store.getSomething()  // error

此外，getter 可以通过 this 访问 state 和/或其他 getter，但 state 是只读的。

Actions

当你像这样定义一个商店时

const store = defineStore({
  // ...other required fields
  actions: {
    doSideEffect() {
      this.xxx = 'xxx'
      return 'ok'
    }
  }
})

可以直接调用它

const returnValue = store.doSideEffect()

Actions可以返回任何值，也可以不返回任何值，并且它可以接收任意数量的不同类型的参数。参数类型和返回类型不能丢失，这意味着类型检查必须在调用端可用。

可以通过this获取和改变state，可以通过this获取getter但是是只读的

type GetGetters<T> = {
  [P in keyof T]: T[P] extends (...arg: any[]) => infer R ? R : never
}
type OptionsType<S, G, A> = {
  id: string
  state: () => Readonly<S>
  getters: G & ThisType<GetGetters<G> & Readonly<S>>
  actions: A & ThisType<A & S>
}
declare function defineStore<S, G, A>(
  store: OptionsType<S, G, A>
): A & Readonly<S> & GetGetters<G>

和 vue 挑战是一样的，都是利用了函数泛型的推断

Camelize

实现 Camelize 将对象从snake_case 转换为camelCase

example:

Camelize<{
  some_prop: string, 
  prop: { another_prop: string },
  array: [{ snake_case: string }]
}>

// expected to be
// {
//   someProp: string, 
//   prop: { anotherProp: string },
//   array: [{ snakeCase: string }]
// }

type TransformCamelcase<T> = T extends `${infer L}_${infer R}`
  ? `${L}${Capitalize<R>}`
  : T

type CamelikeTuple<T> = T extends [infer F, ...infer R]
  ? [Camelize<F>, ...CamelikeTuple<R>]
  : []

type CamelikeObject<T> = {
  [P in keyof T as TransformCamelcase<P>]: Camelize<T[P]>
}

type Camelize<T> = T extends Array<any>
  ? CamelikeTuple<T>
  : T extends {}
  ? CamelikeObject<T>
  : T

Drop String

从字符串中删除指定的字符。

example:

type Butterfly = DropString<'foobar!', 'fb'> // 'ooar!'

type StringToUnion<S extends string> = S extends `${infer F}${infer Rest}`
  ? F | StringToUnion<Rest>
  : never

type DropStringUnion<
  S extends string,
  R
> = S extends `${infer A}${infer B}${infer Rest}`
  ? A extends R
    ? B extends R
      ? `${DropStringUnion<Rest, R>}`
      : `${B}${DropStringUnion<Rest, R>}`
    : B extends R
    ? `${A}${DropStringUnion<Rest, R>}`
    : `${A}${B}${DropStringUnion<Rest, R>}`
  : S extends `${infer A}${infer Rest}`
  ? A extends R
    ? `${DropStringUnion<Rest, R>}`
    : `${A}${DropStringUnion<Rest, R>}`
  : S

type DropString<S extends string, R extends string> = DropStringUnion<
  S,
  StringToUnion<R>
>

Split

example:

type result = Split<'Hi! How are you?', ' '>  // should be ['Hi!', 'How', 'are', 'you?']

type Split<
  S extends string,
  SEP extends string
> = S extends `${infer L}${SEP}${infer R}`
  ? R extends ''
    ? [L]
    : [L, ...Split<R, SEP>]
  : S extends ''
  ? SEP extends ''
    ? []
    : [S]
  : S extends `${infer R}`
  ? [S]
  : string[]

地狱

获取只读字段

实现泛型GetReadonlyKeys<T>，该GetReadonlyKeys<T>返回对象的只读键的并集。

example:

interface Todo {
  readonly title: string
  readonly description: string
  completed: boolean
}

type Keys = GetReadonlyKeys<Todo> // expected to be "title" | "description"

type IsEqual<X, Y, A = true, B = false> = (<T>() => T extends X
  ? 1
  : 2) extends <T>() => T extends Y ? 1 : 2
  ? A
  : B
type GetReadonlyKeys<T> = {
  [P in keyof T]-?: IsEqual<
    { [O in P]: T[P] },
    { -readonly [O in P]: T[P] },
    never,
    P
  >
}[keyof T]

Query String Parser

您需要实现一个类型级解析器来将URL查询字符串解析为对象文字类型。

一些详细需求:

查询字符串中的键值可以被忽略，但仍然被解析为true。例如，'key'没有值，所以解析器的结果是{key: true}。
重复的密钥必须合并成一个。如果具有相同键的值不同，则必须将值合并为元组类型。
当一个键只有一个值时，该值不能包装成元组类型。
如果具有相同键的值出现多次，则必须将其视为一次。例如，key=value&key=value必须只被视为key=value。

type MergeQuery<T ,R , S extends keyof T | keyof R = Extract<keyof T, keyof R> | Extract<keyof R, keyof T>> = {[P in S]: MergeSameArrayItem<[GetValue<T, P>, GetValue<R, P> ]>} & {[P in Exclude<keyof T,S>]: GetValue<T, P>} & {[P in Exclude< keyof R,S>]: GetValue<R, P>}
type MergeSameArrayItem<T extends [unknown, unknown]> = T extends [infer F, infer L]? [F] extends [L] ? [L] extends [F] ? L :[F, L]: [F, L] :never
type GetValue<T, P> = P extends keyof T ? T[P] :never
type ParserParams<P> =  P extends `${infer K}=${infer V}` ? {[P in K]: V} : P extends `${infer L}${infer S}` ? {[I in P]:true}:{}
type MergeIntersection2Obj<T> = {[P in keyof T]: T[P]}
type ParseQueryString<T extends string> = MergeIntersection2Obj<T extends `${infer F}&${infer O}` ? MergeQuery<ParserParams<F> , ParseQueryString<O>> :ParserParams<T>>


type A =  ParseQueryString<''>
type B =  ParseQueryString<'k1'>
type C =  ParseQueryString<'k1&k1'>
type D =  ParseQueryString<'k1&k2'>
type E =  ParseQueryString<'k1=v1'>
type F =  ParseQueryString<'k1=v1&k1=v2'>
type G =  ParseQueryString<'k1=v1&k2=v2'>
type H =  ParseQueryString<'k1=v1&k2=v2&k1=v2'>
type I =  ParseQueryString<'k1=v1&k2'>
type J =  ParseQueryString<'k1=v1&k1=v1'>

slice

实现 Array.slice 函数

example:

type Arr = [1, 2, 3, 4, 5]
type Result = Slice<Arr, 2, 4> // expected to be [3, 4]

type StringEqual<T extends String, R extends String> = T extends R ? R extends T ? true : false : false

type CovertIndex<T extends any[], R extends String, S extends any[] = []> = StringEqual<`${S['length']}`, R> extends true ? T['length'] : T extends [...infer O, infer L] ? CovertIndex<O,R,[...S,L]> : 0
type GetStartSlice<T extends any[], S extends number, O extends any[]> = `${S}` extends `-${infer PS}` ?  StartLeftBegin<T, CovertIndex<O, `${PS}`>>  : StartLeftBegin<T, S>
type StartLeftBegin<T extends any[], R extends number, S extends any[] = []> = StringEqual<`${S['length']}`, `${R}`> extends true ? T : T extends [infer O, ...infer L] ? StartLeftBegin<L,R,[...S,O]> : []

         
type GetEndSlice<T extends any[], S extends number> = `${S}` extends `-${infer PS}` ?  EndRightBegin<T, `${PS}`>  : EndLeftBegin<Arr, `${S}`>
type EndRightBegin<T extends any[], R extends string, S extends any[] = []> = StringEqual<`${S['length']}`, R> extends true ? T : T extends [...infer O, infer L] ? EndRightBegin<O,R,[...S,L]> : []
type EndLeftBegin<T extends any[], R extends string, S extends any[] = []> = StringEqual<`${S['length']}`, R> extends true ? S : T extends [infer O, ...infer L] ? EndLeftBegin<L,R,[...S,O]> : []

type Slice<Arr extends any[], Start extends number=0, End extends number=Arr['length']> = GetStartSlice<GetEndSlice<Arr, End>, Start, Arr>

Integers Comparator

利用ts 实现一个整数比较器，提供了一个enum来指示比较结果，如下所示

If a is greater than b, type should be Comparison.Greater.
If a and b are equal, type should be Comparison.Equal.
If a is lower than b, type should be Comparison.Lower. 注意，a和b可以是正整数或负整数或0，甚至一个是正的，而另一个是负的

type GetPositive<A extends number> = `${A}` extends `-${infer PA}` ? PA : never;
type IsPositive<A extends number> = `${A}` extends `-${infer PA}` ? false : true;
type EasyEqual<A extends number | string, B extends number | string> = A extends B
  ? B extends A
    ? true
    : false
  : false;

/* 
if A > B => false 
if B > A => true
*/
type Compare<
  A extends number | string,
  B extends number | string,
  R extends any[] = []
> = EasyEqual<`${A}`, `${R['length']}`> extends true
  ? true
  : EasyEqual<`${B}`, `${R['length']}`> extends true
  ? false
  : Compare<A, B, [...R, 1]>;

type Comparator<A extends number, B extends number> = EasyEqual<A, B> extends true
  ? Comparison.Equal
  : IsPositive<A> extends true
  ? IsPositive<B> extends true
    ? Compare<A, B> extends true
      ? Comparison.Lower
      : Comparison.Greater
    : Comparison.Greater
  : IsPositive<B> extends true
  ? Comparison.Lower
  : Compare<GetPositive<A>, GetPositive<B>> extends true
  ? Comparison.Greater
  : Comparison.Lower;

剩下的地狱级别的个人觉得涉及到算法偏多一些，就没继续做下去，有兴趣同学的可以玩一玩

TypeScript 类型体操姿势合集<通关总结>--刷完

简单

实现pick

实现 Readonly

元组转换为对象

第一个元素

获取元组长度

扩展 readonly 的表现

Exclude

Awaited

If

Concat

Includes

中等

获取函数返回类型

实现 Omit

实现 Readonly 2

深度 Readonly

元组转合集

可串联构造器

最后一个元素

出堆

Promise.all

Type Lookup

Trim Left

Trim

Capitalize

Replace

ReplaceAll

追加参数

Permutation

Length of String

Flatten

Append to object

交集相等问题

Absolute

String to Union

Merge

CamelCase

KebabCase

Diff

AnyOf

IsNever

IsUnion

ReplaceKeys

Remove Index Signature

百分比解析器

Drop Char

MinusOne

PickByType

StartsWith

EndsWith

PartialByKeys

RequiredByKeys

Mutable

困难

简单的 Vue 类型

科里化 1

Union to Intersection

Get Required

Get Optional

Required Keys

Optional Keys

Capitalize Words

CamelCase

C-printf Parser

Vue Basic Props

IsAny

Typed Get

String to Number

Tuple Filter

Tuple to Enum Object

printf

Deep object to unique

Length of String 2

Union to Tuple

String Join

Deepick

Pinia

Camelize