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

您可以定义一个包含所有函数定义的额外接口。并使用映射类型将这些函数转换为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]），但这将返回所有签名的并集，并且这将不可调用。这是一个有趣的类型来自UnionToIntersection的{{1}}形式的答案，它将我们的签名联合转换为所有签名的交集。

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

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获取this

的一部分

修改如果我们已经有一个基类具有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

自撰写本文以来，打字稿已经提高了它绘制功能的能力。使用puzzle，我们可以用更干净的版本替换AddParameters的多个重载（并且不需要IsValidArg）：

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

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

1 个答案: