为什么打字稿在通过泛型检索函数类型时期望“从不”作为函数参数？

Question

我目前正在尝试从 TS 2.6 切换到 3.4，但遇到了奇怪的问题。这以前有效，但现在它向我展示了一个编译器错误：

type MyNumberType = 'never' | 'gonna';
type MyStringType = 'give' | 'you';
type MyBooleanType = 'up' 

interface Bar {
    foo(key: MyNumberType): number;
    bar(key: MyStringType): string;
    baz(key: MyBooleanType): boolean;
}

function test<T extends keyof Bar>(bar: Bar, fn: T) {
    let arg: Parameters<Bar[T]>[0];
    bar[fn](arg); // error here
}

错误如下：

Argument of type 'Parameters<Bar[T]>' is not assignable to parameter of type 'never'.
Type 'unknown[]' is not assignable to type 'never'.
Type '[number] | [string] | [boolean]' is not assignable to type 'never'.
Type '[number]' is not assignable to type 'never'.

Typescript 操场告诉我该函数的预期参数是“从不”类型：

我根本不希望这里有错误。只有一个函数参数，参数的类型通过Parameters. 为什么函数是 expect never？

Answer 1

问题是编译器不理解arg并且bar[fn]是相关的。它将它们都视为不相关的联合类型，因此期望联合成分的每种组合都是可能的，而大多数组合都不是。

在 TypeScript 3.2 中，您刚刚收到一条错误消息，指出bar[fn]它没有调用签名，因为它是具有不同参数的函数的联合。我怀疑该代码的任何版本都适用于 TS2.6；当然代码Parameters<>没有在那里，因为条件类型直到 TS2.8 才被引入。我尝试以与 TS2.6 兼容的方式重新创建您的代码，例如

interface B {
    foo: MyNumberType,
    bar: MyStringType,
    baz:MyBooleanType
}

function test<T extends keyof Bar>(bar: Bar, fn: T) {
    let arg: B[T]=null!
    bar[fn](arg); // error here
}

并在 TS2.7 中进行了测试，但仍然出现错误。所以我将假设这段代码从未真正起作用。

至于never问题：TypeScript 3.3通过要求参数是来自函数联合的参数的交集，引入了对调用函数联合的支持。这在某些情况下是一种改进，但在您的情况下，它希望参数是一堆不同字符串文字的交集，它会折叠为. 这基本上与之前相同的错误（“你不能称之为”）以更令人困惑的方式表示。never

处理这个问题最直接的方法是使用类型断言，因为在这种情况下你比编译器更聪明：

function test<T extends keyof Bar>(bar: Bar, fn: T) {
    let arg: Parameters<Bar[T]>[0] = null!; // give it some value
    // assert that bar[fn] takes a union of args and returns a union of returns
    (bar[fn] as (x: typeof arg) => ReturnType<Bar[T]>)(arg); // okay
}

类型断言是不安全的，这确实让你对编译器撒谎：

function evilTest<T extends keyof Bar>(bar: Bar, fn: T) {
    // assertion below is lying to the compiler
    (bar[fn] as (x: Parameters<Bar[T]>[0]) => ReturnType<Bar[T]>)("up"); // no error!
}

所以你应该小心。有一种方法可以做一个完全类型安全的版本，强制编译器对每一种可能性进行代码流分析：

function manualTest<T extends keyof Bar>(bar: Bar, fn: T): ReturnType<Bar[T]>;
// unions can be narrowed, generics cannot
// see https://github.com/Microsoft/TypeScript/issues/13995
// and https://github.com/microsoft/TypeScript/issues/24085
function manualTest(bar: Bar, fn: keyof Bar) {
    switch (fn) {
        case 'foo': {
            let arg: Parameters<Bar[typeof fn]>[0] = null!
            return bar[fn](arg);
        }
        case 'bar': {
            let arg: Parameters<Bar[typeof fn]>[0] = null!
            return bar[fn](arg);
        }
        case 'baz': {
            let arg: Parameters<Bar[typeof fn]>[0] = null!
            return bar[fn](arg);
        }
        default:
            return assertUnreachable(fn);
    }
}

但这太脆弱（如果向 中添加方法，则需要更改代码Bar）和重复（一遍又一遍地使用相同的子句），我通常更喜欢上面的类型断言。

好的，希望有帮助；祝你好运！