typescript - 函数 "lacks return statement"但所有路径都有类型保护

Question

我有以下接口(interface)和类型(所有这些都可以更改)

interface Base {
    type: string;
}

interface A extends Base {
    type: "A";
    field: string;
}

interface B extends Base {
    type: "B";
    query: string;
}

interface C extends Base {
    type: "C";
    equal: number;
}

type BaseExtensions = A | B | C;

interface BaseWrapper<R extends BaseExtensions> {
    idType: string;
    base: R;
}

interface And {
    type: "AND";
    rules: Array<BaseWrapper<any>>;
}

interface Or {
    type: "OR";
    rules: Array<BaseWrapper<any>>;
}

type Rule<R extends BaseExtensions> = BaseWrapper<R> | And | Or

我想做的是编写以下函数:

function doAThingBasedOnTheRuleType(rule: Rule<any>): Thing {
    if (isAnd(rule)) {
        return DoAndThing(rule);
    }
    if (isOr(rule)) {
        return DoOrThing(rule);
    }
    if (isA(rule.base)) {
        return DoAThing(rule);
    }
    if (isB(rule.base)) {
        return DoBThing(rule);
    }
    if (isC(rule.Base)) {
        return DoCThing(rule);
    }
    // error, [ts] Function lacks ending return statement and return type does not include 'undefined'.

}

我希望规则以 And | Or | BaseWrapper<A> | BaseWrapper<B> | BaseWrapper<C> 开头应该一一缩小范围。但是，我收到错误 // error, [ts] Function lacks ending return statement and return type does not include 'undefined'.

1- 为什么 TS 无法推断类型？2- 我该如何解决？

我在 TS 2.5.2

Answer 1

TypeScript 关于隐式返回的规则在语法上 被强制执行——在不知道涉及的类型的情况下，需要在函数的所有可到达导出点都有一个 return 语句。

要确定使用类型系统无法访问给定函数的隐式返回，将需要多次“通过”，而类型系统目前不这样做(出于性能/复杂性原因)。

例如，考虑这段代码:

function fn1() {
    const f = fn2();
    if (f === "alpha") {
        return "A";
    } else if (f === "beta") {
        return "B";
    }
}

function fn2() {
    const f = fn1();
    if (f === "A") {
        return "alpha";
    } else if (f === "B") {
        return "beta";
    }
    return "gamma";
}

fn1() 的类型是什么？它可以是 "A"| “乙” | undefined 如果 fn2() 返回的值不是 "alpha" 或 "beta"，或者它可能是 “一个” | "B" 如果这些是唯一的返回值。好吧，让我们检查一下 fn2() —— 它的返回类型是什么？ 那 取决于fn1() 的类型——fn2 返回“alpha” | "beta" 如果 fn1 只返回 "A"| "B"，或返回 "alpha"| “测试版” | "gamma" 如果 undefined 是可能的返回值。

因此，要弄清楚 fn1 的隐式返回的可达性，您必须进行多“轮”推理，根据另一个函数的类型改进一个函数的类型，然后重复，希望您到达一个固定点并且不要无限递归。这比使用隐式返回的句法强制执行单次传递要很多昂贵。

最简单的解决方法是简单地添加一个throw:

    } else if (...) {
       return ...;
    }
    throw new Error("Shouldn't be reachable");
}

或者，如果您真的很喜欢代码覆盖率，请将 if 条件重写为最后一个 block 中的断言:

   } else {
       Debug.assert(x.kind === "B");
       return "C";
   }