Question

假设我有很多工会类型：

var MyComplexType = MyType1 | MyType2 | MyType3 | ... | MyTypeN

其中MyType{N}具有这种签名：

type MyType1 = {
    type: string,
    data: <different data for different types>
}

我知道我可以使用一种类型保护功能，例如。 g。：

function isMyComplexTypeOfMyType1(item: MyComplexType): item is MyType1 {
    return item.type == "type of MyType1"
}

但是在这种情况下，我应该编写很多这类函数。

因此，问题是：我可以在条件语句（if ... else或switch ... case）中动态定义类型吗？例如：

function someFunction(item: MyComplexType) {
    switch (item.type) {
        case "type of MyType1":
            // item is MyType1
            // do something
            break
        case "type of MyType2":
            // item is MyType2
            // do something
            break
        ...
    }
}

Answer 1

如果计划使用switch/case语句检查联合类型的值，则应将其声明为disciminated union，其中将联合的每个组成部分的type属性声明为是相关的string literal，而不仅仅是string。您实际上并不需要条件类型来处理此问题，至少不需要在您的someFunction()实现内部。

例如，假设您的类型如下：

type MyType1 = { type: "type1", data: { a: string, b: number } };
type MyType2 = { type: "type2", data: { c: boolean, d: string } };
type MyType3 = { type: "type3", data: { e: number, f: boolean } };

type MyComplexType = MyType1 | MyType2 | MyType3;

然后，编译器将自动检查MyComplexType["type"]上的检查作为类型防护，如下所示：

const exhaustivenessCheck = (x: never) => x;

function someFunction(item: MyComplexType) {
    switch (item.type) {
        case "type1":
            console.log(2 * item.data.b); // okay
            break;
        case "type2":
            console.log(item.data.d.charAt(0)); // okay
            break;
        case "type3":
            console.log(7 - item.data.e); // okay
            break;
        default:
            throw exhaustivenessCheck(item); // okay
    }
}

如果函数某种程度上属于exhaustivenessCheck()，则throw基本上是default语句。那不应该发生，但是有用的是，如果编译器不认为您检查了所有内容，就会警告您。这是因为exhaustivenessCheck()要求其参数的类型为never，这是不可能发生的。如果您注释掉case "type3"子句，或者稍后再将新的成分添加到MyComplexType联合中，则exhaustivenessCheck()行将引发错误，表明您无法检查案件。

这时您可以停止操作，但是如果您的类型确实是编程的，因为它们仅包含两个属性，一个type判别字符串和一个data属性，那么您可以使用以下命令定义类型这样的重复次数更少：

// a mapping from type string to data type
type MyTypes = {
    type1: { a: string, b: number };
    type2: { c: boolean, d: string };
    type3: { e: number, f: boolean };
}

// convert the mapping to the union of types
type MyType<K extends keyof MyTypes = keyof MyTypes> = {
    [P in K]: { type: P, data: MyTypes[P] }
}[K]

您可以验证MyType或MyType<keyof MyTypes>扩展为我上面定义的MyComplexType联合。您以前的MyType1现在是MyType<"type1">，依此类推。也就是说，如果您需要使用旧名称作为类型，则可以这样操作：

type MyType1 = MyType<"type1">;
type MyType2 = MyType<"type2">;
type MyType3 = MyType<"type3">
type MyComplexType = MyType;

希望有所帮助；祝你好运！

Typescript：在条件语句中使用条件键入

1 个答案: