Question

在Typescript中，如何在编译时将泛型类型限制为几个类之一？例如，如何实现此伪代码？

class VariablyTyped<T has one of types A or B or C> {

    method(hasOneType: T) {
        if T has type A:
            do something assuming type A
        if T has type B:
            do something assuming type B
        if T has type C:
            do something assuming type C
    }
}

此外，我希望能够将属性（或任何变量）分配给其中一个泛型类型选项的特定后代类型，而不仅仅是给定类型之一。例如：

class VariablyTyped<T has one of types A or B or C> {

    descendentClassOfT: T

    method(hasOneType: T) {
        descendentClassOfT = hasOneType
    }
}

class D extends class C {
    methodUniqueToD() { }
}

const v = new VariablyTyped(new D())
v.descendentClassOfT.methodUniqueToD()

这个答案显然不明显，因为我花了几个小时。在我看来，这个问题的某种形式had already been asked，但给出的解决方案甚至都没有为我编译。可能是先前的问题仅在非常具体的背景下得到了回答，因为上票的数量表明它正在解决一些人的问题。

我正在发布这个新问题，以明确说明一般问题，并采取后续解决方案。

Answer 1

我把头撞了几个小时，但回想起来，解决方案似乎很明显。首先，我提出解决方案，然后将其与之前的方法进行比较。（在Typescript 2.6.2中测试过。）

// WORKING SOLUTION: union of types with type checks

class MustBeThis {
    method1() { }
}

class OrThis {
    method2() { }
}

abstract class OrOfThisBaseType {
    method3a() { }
}

class ExtendsBaseType extends OrOfThisBaseType {
    method3b() { }
}

class GoodVariablyTyped<T extends MustBeThis | OrThis | OrOfThisBaseType> {
    extendsBaseType: T;

    constructor(hasOneType: T) {
        if (hasOneType instanceof MustBeThis) {
            hasOneType.method1();
        }
        else if (hasOneType instanceof OrThis) {
            hasOneType.method2();
        }
        // either type-check here (as implemented) or typecast (commented out)
        else if (hasOneType instanceof OrOfThisBaseType) {
            hasOneType.method3a();
            // (<OrOfThisBaseType>hasOneType).method3a();
            this.extendsBaseType = hasOneType;
        }
    }
}

以下对此解决方案的检查编译得很好：

const g1 = new GoodVariablyTyped(new MustBeThis());
const g1t = new GoodVariablyTyped<MustBeThis>(new MustBeThis());
const g1e: MustBeThis = g1.extendsBaseType;
const g1te: MustBeThis = g1t.extendsBaseType;

const g2 = new GoodVariablyTyped(new OrThis());
const g2t = new GoodVariablyTyped<OrThis>(new OrThis());
const g2e: OrThis = g2.extendsBaseType;
const g2te: OrThis = g2t.extendsBaseType;

const g3 = new GoodVariablyTyped(new ExtendsBaseType());
const g3t = new GoodVariablyTyped<ExtendsBaseType>(new ExtendsBaseType());
const g3e: ExtendsBaseType = g3.extendsBaseType;
const g3te: ExtendsBaseType = g3t.extendsBaseType;

将上述方法与声明泛型为类选项交集的previously accepted answer进行比较：

// NON-WORKING SOLUTION A: intersection of types

class BadVariablyTyped_A<T extends MustBeThis & OrThis & OrOfThisBaseType> {
    extendsBaseType: T;

    constructor(hasOneType: T) {
        if (hasOneType instanceof MustBeThis) {
            (<MustBeThis>hasOneType).method1();
        }
        // ERROR: The left-hand side of an 'instanceof' expression must be of type
        // 'any', an object type or a type parameter. (parameter) hasOneType: never
        else if (hasOneType instanceof OrThis) {
            (<OrThis>hasOneType).method2();
        }
        else {
            (<OrOfThisBaseType>hasOneType).method3a();
            this.extendsBaseType = hasOneType;
        }
    }
}

// ERROR: Property 'method2' is missing in type 'MustBeThis'.
const b1_A = new BadVariablyTyped_A(new MustBeThis());
// ERROR: Property 'method2' is missing in type 'MustBeThis'.
const b1t_A = new BadVariablyTyped_A<MustBeThis>(new MustBeThis());

// ERROR: Property 'method1' is missing in type 'OrThis'.
const b2_A = new BadVariablyTyped_A(new OrThis());
// ERROR: Property 'method1' is missing in type 'OrThis'.
const b2t_A = new BadVariablyTyped_A<OrThis>(new OrThis());

// ERROR: Property 'method1' is missing in type 'ExtendsBaseType'.
const b3_A = new BadVariablyTyped_A(new ExtendsBaseType());
// ERROR: Property 'method1' is missing in type 'ExtendsBaseType'.
const b3t_A = new BadVariablyTyped_A<ExtendsBaseType>(new ExtendsBaseType());

还将上述工作方法与another suggested solution进行比较，其中约束泛型类型以扩展实现所有类接口选项的接口。此处发生的错误表明它在逻辑上与先前的非工作解决方案相同。

// NON-WORKING SOLUTION B: multiply-extended interface

interface VariableType extends MustBeThis, OrThis, OrOfThisBaseType { }

class BadVariablyTyped_B<T extends VariableType> {
    extendsBaseType: T;

    constructor(hasOneType: T) {
        if (hasOneType instanceof MustBeThis) {
            (<MustBeThis>hasOneType).method1();
        }
        // ERROR: The left-hand side of an 'instanceof' expression must be of type
        // 'any', an object type or a type parameter. (parameter) hasOneType: never
        else if (hasOneType instanceof OrThis) {
            (<OrThis>hasOneType).method2();
        }
        else {
            (<OrOfThisBaseType>hasOneType).method3a();
            this.extendsBaseType = hasOneType;
        }
    }
}

// ERROR: Property 'method2' is missing in type 'MustBeThis'.
const b1_B = new BadVariablyTyped_B(new MustBeThis());
// ERROR: Property 'method2' is missing in type 'MustBeThis'.
const b1t_B = new BadVariablyTyped_B<MustBeThis>(new MustBeThis());

// ERROR: Property 'method1' is missing in type 'OrThis'.
const b2_B = new BadVariablyTyped_B(new OrThis());
// ERROR: Property 'method1' is missing in type 'OrThis'.
const b2t_B = new BadVariablyTyped_B<OrThis>(new OrThis());

// ERROR: Property 'method1' is missing in type 'ExtendsBaseType'.
const b3_B = new BadVariablyTyped_B(new ExtendsBaseType());
// ERROR: Property 'method1' is missing in type 'ExtendsBaseType'.
const bt_B = new BadVariablyTyped_B<ExtendsBaseType>(new ExtendsBaseType());

具有讽刺意味的是，我后来解决了我的应用程序特定问题，而不必约束泛型类型。也许其他人应该从我的课程中吸取教训，并首先尝试找到另一种更好的方法来完成这项工作。

将泛型类型限制为Typescript

1 个答案: