有没有办法从重载的 TS 方法中提取所有函数签名？

Question

基本上我只是想包装一个有多个签名的函数。是否有任何干净的方法可以在不重新硬编码所有签名的情况下做到这一点？我只希望下面的bar 接受与foo 相同的任何参数

declare function foo(x: string): number;
declare function foo(x: string, y: number): 42;
declare function foo(x: number): string;

type fooArgs = Parameters<typeof foo>; // this only extracts from the last signature
declare function bar(...args: fooArgs): string[]

const a = foo(123);        // fine
const b = foo('123');      // fine
const c = foo('123', 456); // fine

const x = bar(123);        // fine
const y = bar('123');      // fails because it expects (x: number) => string
const z = bar('123', 456); // fails

ts playground

Answer 1

这是设计使然。它总是返回最后一个重载的签名。看到这个issue/28789

但是，还有另一种方法。

请记住，重载只是函数类型的交集。

我们可以声明一个类型来保存我们所有的重载签名：

type Signatures = {
    1: (x: string) => number,
    2: (x: string, y: number) => 42
    3: (x: number) => string
}

现在，为了创建重载，我们需要获取所有对象属性的并集并将它们相交。

// credits goes to https://stackoverflow.com/a/50375286
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
    k: infer I
) => void
    ? I
    : never;

type Values<T> = T[keyof T]

type Overloading = UnionToIntersection<Values<Signatures>>

它按预期工作：

declare const foo: Overloading;

const a = foo(123); // string
const b = foo('123'); // number
const c = foo('123', 456); // 42

现在，很容易获得所有允许参数的并集：

//  [x: string] | [x: string, y: number] | [x: number]
type fooArgs = Parameters<Values<Signatures>>;
declare function bar(...args: fooArgs): string[]


const x = bar(123); // string[]
const y = bar('123'); // string[]
const z = bar('123', 456); // string[]

完整代码：

type Signatures = {
    1: (x: string) => number,
    2: (x: string, y: number) => 42
    3: (x: number) => string
}

// credits goes to https://stackoverflow.com/a/50375286
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
    k: infer I
) => void
    ? I
    : never;

type Values<T> = T[keyof T]

type Overloading = UnionToIntersection<Values<Signatures>>

declare const foo: Overloading;

const a = foo(123); // string
const b = foo('123'); // number
const c = foo('123', 456); // 42


//  [x: string] | [x: string, y: number] | [x: number]
type fooArgs = Parameters<Values<Signatures>>;
declare function bar(...args: fooArgs): string[]


const x = bar(123); // string[]
const y = bar('123'); // string[]
const z = bar('123', 456); // string[]

Playground

Answer 2

我发现这个问题是因为我想要一些相同的结果，但是对于我懒得自己编写的一堆可链接的写入方法。

这就是我从captain-yossarian's answer 实现UnionToIntersection 类型的方式：

type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  k: infer I
) => void
  ? I
  : never;

// create accessor signature type. Generics are just for method params & return type.
type AccessorSignature<Self, In, Out = In> = {
  get(): Out;
  set(value: In): Self;
};

// apply union to intersection on accessor signature
type Accessor<Self, In, Out = In> = UnionToIntersection<
  AccessorSignature<Self, In, Out>[keyof AccessorSignature<Self, In, Out>]
>;

// create a class with the typed chainable accessors
declare class YeetProps {
  foo: Accessor<Yeet, string | number, string>;
  bar: Accessor<Yeet, string>;
  baz: Accessor<Yeet, boolean>;
}

// implement it in my final class
class Yeet extends YeetProps {}

const fooValue = new Yeet().foo(); // read string value

// chain write
new Yeet().foo("woop!").bar("this is amazing").baz(true);

我最终会使用Proxy 来实际实现这些方法。