我可以在 Typescript 中重用函数的参数定义吗？

Question

我想捕获一个函数的编译时参数结构，我可以在具有相似签名的多个函数定义中重用它。我认为这可能与this TS issue 或更具体地this one 类似，但我不确定我的用例是否一定符合这些建议，所以它可能可以做到这在当前的打字稿中。我想要做的是：

type FooArgs = ?{x: string, y: number}?; // syntax?
class MyEmitter extends EventEmitter {
  on(event: "foo", (...args: ...FooArgs) => void): this;
  emit(event: "foo", ...args: ...FooArgs): boolean;
}

这可能不是最聪明的方法。我也很乐意了解将一种方法的参数列表“复制”到另一种方法的其他方法：

class MyEmitter extends EventEmitter {
  emit(event: "foo", x: string, y: number): boolean;
  on(event: "foo", (argumentsof(MyEmitter.emit)) => void): this;
}

但我不相信存在任何这样的关键字/内置关键字。

顺便说一句，我尝试了一种类似于this article 中早期示例的方法，但即使使用后面描述的所有复杂类型操作，该方法也只允许发出零个或一个参数的事件。我希望，对于这个有限的用例，可能有更聪明的方法。

Answer 1

您可以定义一个包含所有函数定义的额外接口。并使用映射类型将这些函数转换为on 的签名和emit 的签名。两者的过程有点不同，所以我会解释一下。

让我们考虑以下事件签名接口：

interface Events {
    scroll: (pos: Position, offset: Position) => void,
    mouseMove: (pos: Position) => void,
    mouseOther: (pos: string) => void,
    done: () => void
}

对于on，我们要创建新函数，第一个参数是接口中属性的名称，第二个参数是函数本身。为此，我们可以使用映射类型

type OnSignatures<T> = { [P in keyof T] : (event: P, listener: T[P])=> void }

对于emit，我们需要给每个函数添加一个参数，即事件名称，我们可以使用answer中的方法

type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;
type AddParameters<T, P> =
    T extends (a: infer A, b: infer B, c: infer C) => infer R ? (
        IsValidArg<C> extends true ? (event: P, a: A, b: B, c: C) => R :
        IsValidArg<B> extends true ? (event: P, a: A, b: B) => R :
        IsValidArg<A> extends true ? (event: P, a: A) => R :
        (event: P) => R
    ) : never;

type EmitSignatures<T> = { [P in keyof T] : AddParameters<T[P], P>};

现在我们已经转换了原始界面，我们需要将所有功能混合为一个。要获得所有签名，我们可以使用T[keyof T]（即EmitSignatures<Events>[keyof Events]），但这将返回所有签名的联合，并且不可调用。这就是来自this 答案的一个有趣类型以UnionToIntersection 的形式出现的地方，它将我们的签名联合转换为所有签名的交集。

把它们放在一起，我们得到：

interface Events {
    scroll: (pos: Position, offset: Position) => void,
    mouseMove: (pos: Position) => void,
    mouseOther: (pos: string) => void,
    done: () => void
}
type UnionToIntersection<U> =
    (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;

type OnSignatures<T> = { [P in keyof T]: (event: P, listener: T[P]) => void }
type OnAll<T> = UnionToIntersection<OnSignatures<T>[keyof T]>

type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;
    // Works for up to 3 parameters, but you could add more as needed
type AddParameters<T, P> =
    T extends (a: infer A, b: infer B, c: infer C) => infer R ? (
        IsValidArg<C> extends true ? (event: P, a: A, b: B, c: C) => R :
        IsValidArg<B> extends true ? (event: P, a: A, b: B) => R :
        IsValidArg<A> extends true ? (event: P, a: A) => R :
        (event: P) => R
    ) : never;

type EmitSignatures<T> = { [P in keyof T]: AddParameters<T[P], P> };

type EmitAll<T> = UnionToIntersection<EmitSignatures<T>[keyof T]>

interface TypedEventEmitter<T> {
    on: OnAll<T>
    emit: EmitAll<T>
}

declare const myEventEmitter: TypedEventEmitter<Events>;

myEventEmitter.on('mouseMove', pos => { }); // pos is position 
myEventEmitter.on('mouseOther', pos => { }); // pos is string
myEventEmitter.on('done', function () { });

myEventEmitter.emit('mouseMove', new Position());

myEventEmitter.emit('done');

特别感谢@jcalz 提供了puzzle 的一部分

---

编辑 如果我们已经有一个基类，它具有on 和emit 的非常通用的实现，我们需要对类型系统进行一些操作。

// Base class
class EventEmitter {
    on(event: string | symbol, listener: (...args: any[]) => void): this { return this;}
    emit(event: string | symbol, ...args: any[]): this { return this;}
}

interface ITypedEventEmitter<T> {
    on: OnAll<T>
    emit: EmitAll<T>
}
// Optional derived class if we need it (if we have nothing to add we can just us EventEmitter directly 
class TypedEventEmitterImpl extends EventEmitter  {
}
// Define the actual constructor, we need to use a type assertion to make the `EventEmitter` fit  in here 
const TypedEventEmitter : { new <T>() : TypedEventEmitter<T> } =  TypedEventEmitterImpl as any;
// Define the type for our emitter 
type TypedEventEmitter<T> =  ITypedEventEmitter<T> & EventEmitter // Order matters here, we want our overloads to be considered first

// We can now build the class and use it as before
const myEventEmitter: TypedEventEmitter<Events> = new TypedEventEmitter<Events>();

为 3.0 编辑

自撰写本文以来，typescript 已经提高了它映射函数的能力。使用Tuples in rest parameters and spread expressions ，我们可以将AddParameters 的多个重载替换为更简洁的版本（并且不需要IsValidArg）：

type AddParameters<T, P> =
    T extends (...a: infer A) => infer R ? (event: P, ...a: A) => R : never;