减少使用特殊方法的课堂打字

我正在寻找一种减少打字稿输入中冗余的方法。我正在创建一种特定类型的类,其中:

  • 该类中的每个方法都有一个参数
  • 每个参数键都有对应的方法
  • 该方法中还允许使用来自相应方法的参数(第一个和唯一一个)。

这是一个上课的例子:

interface Wood {}
interface Chair {}
interface DiningRoom {}
interface LivingRoom {}
interface Nail {}

class House {

    constructor () {

    }

    wood (i: {tree: string}): Wood {
        return {}
    }

    nails (i: {nails: number}): Nail[] {
        return [{}]
    }

    chair (i: {wood: Wood,nails: Nail[]} 
        & Parameters<House['wood']>[0]
        & Parameters<House['nails']>[0]    
    ): Chair {
        return {}
    }

    diningRoom (i: {chair: Chair } & Parameters<House['chair']>[0]): DiningRoom {
        return {}
    }

    livingRoom (i: {chair: Chair } & Parameters<House['chair']>[0]): LivingRoom {
        return {}
    }

}

我正在寻找一个抽象类通用类型,它们将减少编写& Parameters<House['wood']>[0]的重复性。理想情况下,一个抽象类可以将i: {chair: Chair}作为参数并知道添加& Parameters<House['chair']>[0]

zmm_kj 回答:减少使用特殊方法的课堂打字

我不确定我是否了解您在做什么,也不知道是否有可能通过继承执行任何操作,从而使子类方法参数自动与事物相交。据我所知,与您的参数相对应的通用类型如下所示:

type AllKeys<T> = T extends any ? keyof T : never;
type MakeParam<H extends Record<K,(x: any) => any>,K extends keyof any> =
  { [Q in K]: Parameters<H[Q]>[0] }[K] extends infer L ?
  { [Q in AllKeys<L>]: Extract<L,Record<Q,any>>[Q] } extends infer M ?
  { [P in K | keyof M]:
    (P extends keyof M ? M[P] : unknown) &
    (P extends K ? ReturnType<H[P]> : unknown)
  } : never : never;

您可以这样使用它:

type Test = MakeParam<House,"wood">;
/* type Test = {
    wood: Wood;
    tree: string;
} */

或对于多个键,像这样的联合:

type Test2 = MakeParam<House,"wood" | "nails">;
/* type Test2 = {
    wood: Wood;
    nails: number & Nail[];
    tree: string;
} */

请注意,number & Nail[]。那很奇怪而且没有用,但是正是您当前代码所需要的,所以您就可以了。假定您传递给nails()方法的对象不应具有名为nails的键。重复项将被相交;使用风险自负。

然后,您可以像这样重构House的定义:

class House {

  constructor() {
  }

  wood(i: { tree: string }): Wood {
    return {}
  }

  nails(i: { nails: number }): Nail[] {
    return [{}]
  }

  chair(i: MakeParam<House,"wood" | "nails">): Chair {
    return {}
  }

  diningRoom(i: MakeParam<House,"chair">): DiningRoom {
    return {}
  }

  livingRoom(i: MakeParam<House,"chair">): LivingRoom {
    return {}
  }

}

我想它的工作原理与您给定的代码相同。


我想您想对MakeParam<H,K>进行解释。那可能真的很罗word,所以我只给一个草图:

  • { [Q in K]: Parameters<H[Q]>[0] }[K] extends infer L ? ... : never

    这定义了类型L,它是K联合中命名的方法的所有参数的联合。当HHouse并且K"wood" | "nails"时,您得到{ tree: string } | { nails: number }

  • { [Q in AllKeys<L>]: Extract<L,any>>[Q] } extends infer M ? ... : never

    这定义了类型M,该类型采用L,并通过从所有联合件中提取所有属性将联合变成“交集”。当HHouseK"wood" | "nails"时,您得到{ tree: string,nails: number }

  • { [P in K | keyof M]: (P extends keyof M ? M[P] : unknown) & (P extends K ? ReturnType<H[P]> : unknown) }

    这将创建一个具有M中所有属性的新对象,并添加名称为K且类型为K的方法的返回类型的属性。通常,每个属性名称都应该只出现在Kkeyof M中,如果我确定可以做类似M[P] | ReturnType<H[P]>的事情(需要进行一些keyof检查,制作该编译器),但是您的nails定义让我暂停了一下,我必须确保它的行为与您当前的行为相同,并带有有趣的number & Nail[]类型。


好的,希望能有所帮助。祝你好运!

Link to code

本文链接:https://www.f2er.com/3169843.html

大家都在问