TS类型挑战题目记录-中等篇3

Absolute

• 实现一个接收string,number或bigInt类型参数的Absolute类型,返回一个正数字符串。

  type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer U}` ? U : `${T}`
  
  type cases = [
    Expect<Equal<Absolute<0>, '0'>>,
    Expect<Equal<Absolute<-0>, '0'>>,
    Expect<Equal<Absolute<10>, '10'>>,
    Expect<Equal<Absolute<-5>, '5'>>,
    Expect<Equal<Absolute<'0'>, '0'>>,
    Expect<Equal<Absolute<'-0'>, '0'>>,
    Expect<Equal<Absolute<'10'>, '10'>>,
    Expect<Equal<Absolute<'-5'>, '5'>>,
    Expect<Equal<Absolute<-1_000_000n>, '1000000'>>,
    Expect<Equal<Absolute<9_999n>, '9999'>>,
  ]

String to Union

• 实现一个将接收到的String参数转换为一个字母Union的类型。

  type StringToUnion<T extends string> = T extends `${infer U}${infer Rest}` ? U | StringToUnion<Rest> : never
  
  type cases = [
    Expect<Equal<StringToUnion<''>, never>>,
    Expect<Equal<StringToUnion<'t'>, 't'>>,
    Expect<Equal<StringToUnion<'hello'>, 'h' | 'e' | 'l' | 'l' | 'o'>>,
    Expect<Equal<StringToUnion<'coronavirus'>, 'c' | 'o' | 'r' | 'o' | 'n' | 'a' | 'v' | 'i' | 'r' | 'u' | 's'>>,
  ]

Merge

• 将两个类型合并成一个类型，第二个类型的键会覆盖第一个类型的键。

  type Merge<F, S> = { [key in (keyof F | keyof S)]: key extends keyof S ? S[key] : key extends keyof F ? F[key] : never }
  
  type Foo = {
    a: number
    b: string
  }
  type Bar = {
    b: number
    c: boolean
  }
  
  type cases = [
    Expect<Equal<Merge<Foo, Bar>, {
      a: number
      b: number
      c: boolean
    }>>,
  ]

KebabCase

• 用 kebab-case 替换 camelCase 或 PascalCase 字符串。

  type KebabCase<S extends string> = S extends `${infer Start}${infer Rest}`
    ? Rest extends Uncapitalize<Rest>
      ? `${Lowercase<Start>}${KebabCase<Rest>}`
      : `${Lowercase<Start>}-${KebabCase<Rest>}`
    : S
  
  type cases = [
    Expect<Equal<KebabCase<'FooBarBaz'>, 'foo-bar-baz'>>,
    Expect<Equal<KebabCase<'fooBarBaz'>, 'foo-bar-baz'>>,
    Expect<Equal<KebabCase<'foo-bar'>, 'foo-bar'>>,
    Expect<Equal<KebabCase<'foo_bar'>, 'foo_bar'>>,
    Expect<Equal<KebabCase<'Foo-Bar'>, 'foo--bar'>>,
    Expect<Equal<KebabCase<'ABC'>, 'a-b-c'>>,
    Expect<Equal<KebabCase<'-'>, '-'>>,
    Expect<Equal<KebabCase<''>, ''>>,
    Expect<Equal<KebabCase<'😎'>, '😎'>>,
  ]

Diff

• 获取两个接口类型中的差值属性。

  type Diff<O, O1> = { [key in (keyof O | keyof O1) as key extends keyof O ? key extends keyof O1 ? never : key : key]: key extends keyof O ? O[key] : key extends keyof O1 ? O1[key] : never}
  
  type Foo = {
    name: string
    age: string
  }
  type Bar = {
    name: string
    age: string
    gender: number
  }
  type Coo = {
    name: string
    gender: number
  }
  
  type cases = [
    Expect<Equal<Diff<Foo, Bar>, { gender: number }>>,
    Expect<Equal<Diff<Bar, Foo>, { gender: number }>>,
    Expect<Equal<Diff<Foo, Coo>, { age: string; gender: number }>>,
    Expect<Equal<Diff<Coo, Foo>, { age: string; gender: number }>>,
  ]

AnyOf

• 在类型系统中实现类似于 Python 中 any 函数。类型接收一个数组，如果数组中任一个元素为真，则返回 true，否则返回 false。如果数组为空，返回 false。

  type AnyOf<T extends readonly any[]> = T extends [infer First, ...infer Rest]
    ? First extends (false | 0 | '' | [] | Record<string, never> | undefined | null) ? AnyOf<Rest> : true
    : false
  
  type cases = [
    Expect<Equal<AnyOf<[1, 'test', true, [1], { name: 'test' }, { 1: 'test' }]>, true>>,
    Expect<Equal<AnyOf<[1, '', false, [], {}]>, true>>,
    Expect<Equal<AnyOf<[0, 'test', false, [], {}]>, true>>,
    Expect<Equal<AnyOf<[0, '', true, [], {}]>, true>>,
    Expect<Equal<AnyOf<[0, '', false, [1], {}]>, true>>,
    Expect<Equal<AnyOf<[0, '', false, [], { name: 'test' }]>, true>>,
    Expect<Equal<AnyOf<[0, '', false, [], { 1: 'test' }]>, true>>,
    Expect<Equal<AnyOf<[0, '', false, [], { name: 'test' }, { 1: 'test' }]>, true>>,
    Expect<Equal<AnyOf<[0, '', false, [], {}, undefined, null]>, false>>,
    Expect<Equal<AnyOf<[]>, false>>,
  ]

IsNever

• 实现一个类型IsNever，它采用输入类型T。如果的类型解析为never，则返回true，否则为false。

  type IsNever<T> = [T] extends [never] ? true: false
  
  type cases = [
    Expect<Equal<IsNever<never>, true>>,
    Expect<Equal<IsNever<never | string>, false>>,
    Expect<Equal<IsNever<''>, false>>,
    Expect<Equal<IsNever<undefined>, false>>,
    Expect<Equal<IsNever<null>, false>>,
    Expect<Equal<IsNever<[]>, false>>,
    Expect<Equal<IsNever<{}>, false>>,
  ]

IsUnion

• 实现一个类型IsUnion，它接受一个输入类型T并返回T是否解析为联合类型。

  type IsUnion<T, K = T> = [T] extends [never] ? false : T extends K ? [K] extends [T] ? false : true : never
  
  type cases = [
    Expect<Equal<IsUnion<string>, false>>,
    Expect<Equal<IsUnion<string | number>, true>>,
    Expect<Equal<IsUnion<'a' | 'b' | 'c' | 'd'>, true>>,
    Expect<Equal<IsUnion<undefined | null | void | ''>, true>>,
    Expect<Equal<IsUnion<{ a: string } | { a: number }>, true>>,
    Expect<Equal<IsUnion<{ a: string | number }>, false>>,
    Expect<Equal<IsUnion<[string | number]>, false>>,
    // Cases where T resolves to a non-union type.
    Expect<Equal<IsUnion<string | never>, false>>,
    Expect<Equal<IsUnion<string | unknown>, false>>,
    Expect<Equal<IsUnion<string | any>, false>>,
    Expect<Equal<IsUnion<string | 'a'>, false>>,
    Expect<Equal<IsUnion<never>, false>>,
  ]

ReplaceKeys

• 实现一个类型ReplaceKeys，用于替换联合类型中的键，如果某个类型没有这个键，只需跳过替换，一个类型需要三个参数。

  type ReplaceKeys<U, T, Y> = { [key in keyof U]: key extends T
    ? key extends keyof Y ? Y[key] : never
    : U[key] 
    } 
  
  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 ReplacedNodeA = {
    type: 'A'
    name: number
    flag: string
  }
  
  type ReplacedNodeB = {
    type: 'B'
    id: number
    flag: string
  }
  
  type ReplacedNodeC = {
    type: 'C'
    name: number
    flag: string
  }
  
  type NoNameNodeA = {
    type: 'A'
    flag: number
    name: never
  }
  
  type NoNameNodeC = {
    type: 'C'
    flag: number
    name: never
  }
  
  type Nodes = NodeA | NodeB | NodeC
  type ReplacedNodes = ReplacedNodeA | ReplacedNodeB | ReplacedNodeC
  type NodesNoName = NoNameNodeA | NoNameNodeC | NodeB
  
  type cases = [
    Expect<Equal<ReplaceKeys<Nodes, 'name' | 'flag', { name: number; flag: string }>, ReplacedNodes>>,
    Expect<Equal<ReplaceKeys<Nodes, 'name', { aa: number }>, NodesNoName>>,
  ]

Remove Index Signature

• 实现RemoveIndexSignature＜T＞，从对象类型中排除索引签名。

  type RemoveIndexSignature<T> = [key in keyof T as string extends key
      ? never
      : number extends key
      ? never
      : symbol extends key
      ? never
      : key]: T[key];
  
  type Foo = {
    [key: string]: any
    foo(): void
  }
  
  type Bar = {
    [key: number]: any
    bar(): void
    0: string
  }
  
  const foobar = Symbol('foobar')
  type FooBar = {
    [key: symbol]: any
    [foobar](): void
  }
  
  type Baz = {
    bar(): void
    baz: string
  }
  
  type cases = [
    Expect<Equal<RemoveIndexSignature<Foo>, { foo(): void }>>,
    Expect<Equal<RemoveIndexSignature<Bar>, { bar(): void; 0: string }>>,
    Expect<Equal<RemoveIndexSignature<FooBar>, { [foobar](): void }>>,
    Expect<Equal<RemoveIndexSignature<Baz>, { bar(): void; baz: string }>>,
  ]