泛型类的构造函数中可选字段的默认值

Question

我试图弄清楚是否有可能（仅使用类型声明）以某种方式适合可选字段的具体默认值 --- 在泛型类的上下文中，这样这个默认值的类型仍然是绑定到另一个必填字段

    type Handler<T> = (msg: T) => boolean;

    type Transformer<T> = (msg: SimpleMsg) => T;

    class Consumer<T> {

        handler: Handler<T>;
        transformer: Transformer<T>;

        constructor(handler: Handler<T>, transformer?: Transformer<T>) {
            this.handler = handler;
            this.transformer = transformer || defaultTransformer
        }

    }

默认转换器可以是这样的（只是传递值）：

    const defaultTransformer = (msg: SimpleMsg) => {
        console.log('BoringTranfomer! ' + JSON.stringify(msg));
        return msg;
    } 

目前它（正确地）警告我 T 可以用与 SimpleMsg 无关的类型实例化

因此，我会 - 以某种方式想以 terms 的变压器（类型？）定义处理程序的类型（反之亦然？） - 并强制该类型为 @987654326 @以防变压器未定义（即未提供）

我知道可以使用工厂方法或其他方法来解决它，我将处理程序明确定义为Handler<SimpleMsg>，但我真的想知道它是否可以通过类型和单个入口点解决

谢谢！

Answer 1

Transformer 返回T，所以我们不可能在不知道T 是什么的情况下创建默认值。但是您在这里的想法是正确的：

如果转换器未定义（即未提供），则强制该类型为 SimpleMsg

构造函数重载

我们可以通过使用多个参数类型重载constructor 函数来做到这一点。我们允许任何匹配的 handler 和 transformer 函数对用于相同的 T 或只是一个 handler，它需要一个 SimpleMsg。 Typescript 在第二种情况下无法推断出T 的类型，会返回Consumer<unknown>，因此我们必须将类的默认值T 设置为SimpleMsg。

构造函数的主体只知道实现签名中的类型，这与您之前的签名相同。所以我们确实需要断言defaultTransformer 是正确的类型。

（我将 Transformer 重命名为 MsgTransformer 以避免出现重复的类型错误）

class Consumer<T = SimpleMsg> {

    handler: Handler<T>;
    transformer: MsgTransformer<T>;

    // if a transformer is provided, it must match the handler    
    constructor(handler: Handler<T>, transformer: MsgTransformer<T>)
    // if no transformer is provided, then the handler must be for type SimpleMsg
    constructor(handler: Handler<SimpleMsg>)
    // implementation signature which combines all overloads
    constructor(handler: Handler<T>, transformer?: MsgTransformer<T>) {
        this.handler = handler;
        this.transformer = transformer || defaultTransformer as MsgTransformer<T>;
    }

}

测试用例：

// CAN pass just a handler for a SimpleMsg
const a = new Consumer((msg: SimpleMsg) => true);  // <SimpleMsg>
const b = new Consumer(() => true); // <SimpleMsg>
// CANNOT pass just a handler for another type
const c = new Consumer((msg: { something: string }) => true); // error as expected
// CAN pass a handler and a transformer that match
const d = new Consumer((msg: { something: string }) => true, (msg: SimpleMsg) => ({ something: "" })); // generic <{something: string}>
// CANNOT have mismatch between handler and transformer
const e = new Consumer((msg: { something: string }) => true, (msg: SimpleMsg) => ({})); // error as expected

Typescript Playground Link

编辑：键入选项对象

如果handler 和transformer 是同一对象上的两个属性，我们不会使用重载。我们只会为参数创建一个更复杂的类型。

constructor({handler, transformer}: Options<T>) {

只有当为defaultTransformer 返回的SimpleMsg 可分配给T 时，我们才能使用使transformer 成为可选的条件类型。

type Options<T> = SimpleMsg extends T ? {
    handler: Handler<T>;
    transformer?: MsgTransformer<T>; // make optional
} : {
    handler: Handler<T>;
    transformer: MsgTransformer<T>;
}

或者我们可以使用联合类型。这不太安全，因为您可以在传递Handler<SimpleMsg> (new Consumer<SomeWrongType>(options)) 时手动将T 声明为任意类型。但这似乎不太可能成为问题。

type Options<T> = {
    handler: Handler<T>;
    transformer: MsgTransformer<T>;
} | {
    handler: Handler<SimpleMsg>;
    transformer?: never; // need this in order to destructure
}