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

Question

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

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

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

让我们考虑以下事件签名接口(interface):

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

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

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;