首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >函数从参数类型返回的TypeScript映射

问函数从参数类型返回的TypeScript映射
EN

Stack Overflow用户
提问于 2020-02-29 02:19:59
回答 1查看 513关注 0票数 1

我想编写一个函数,其返回类型取决于它的参数类型。下面是我试过的。

代码语言:javascript
复制
type Options = "First" | "Second";

type ArgType<T extends Options> = { type: T } & {
  First: { value: number };
  Second: { value: string };
}[T];

type RetType<T extends Options> = {
  First: number;
  Second: boolean;
}[T];

function f<T extends Options>(arg: ArgType<T>): RetType<T> {
  if (arg.type === "First") {
    // T is "First"
    // ArgType<"First"> is { type: "First"} & { value: number }
    // RetType<"First"> is number
    return 23; // Error: Type '23' is not assignable to type '{ First: number; Second: boolean; }[T]'.
  } else {
    // T is "Second"
    // ArgType<"Second"> is { type: "Second" } & { value: string }
    // RetType<"Second"> is boolean
    return false; // Error: Type 'false' is not assignable to type '{ First: number; Second: boolean; }[T]'.
  }
}

// Example usage of function f.
const x = f({ type: "Second", value: "Hello" }); // Type of x correctly inferred as boolean.
const y = f({ type: "First", value: 3 }); // Type of y correctly inferred as number.

当我试图从function f返回时,我会得到类型错误。

  • 如何实现<T extends Options>(arg: ArgType<T>): RetType<T>类型的函数
EN

回答 1

Stack Overflow用户

回答已采纳

发布于 2020-02-29 20:12:32

这是TypeScript中已知的一个痛点;有关讨论,请参见微软/打字稿#13995和微软/打字稿#24085。在以下代码中:

代码语言:javascript
复制
declare const arg: ArgType<"First"> | ArgType<"Second">;
if (arg.type === "First") { 
    // true block
    arg.value.toFixed(); // okay
} else {
    // false block
    arg.value.toLowerCase(); // okay
}

编译器能够将arg缩小到真块中的ArgType<"First">,在false块中缩小到ArgType<"Second">。这是因为arg是一个歧视结合类型,您正在检查一个判别属性。基于控制流的类型收缩非常有用,但它只适用于缩小arg这样的值的类型;在下面的代码中,它不会缩小类型参数(如T ):

代码语言:javascript
复制
function fError<T extends Options>(arg: ArgType<T>): RetType<T> {
    if (arg.type === "First") {
        // true block
        arg.value.toFixed(); // error
        return 23; // error
    } else {
        // false block
        arg.value.toLowerCase(); // error
        return false; // error
    }
}

这里有类似的代码,但arg不是一个具体的联合类型,而是依赖于泛型类型参数的类型。控制流收缩停止工作。即使编译器可以看到arg在真正的块中是一个ArgType<"First">,而在false other中是一个ArgType<"Second">,这仍然不会对T产生任何影响。因此,编译器将不会验证23或false是否可分配给RetType<T>。为了实现这一点,编译器需要将T缩小到真块中的"First",而在false块中缩小到"Second"。一般来说,这不是一件好事(如果T实际上是完整的"First" | "Second"联合呢?),但是编译器完全放弃的当前行为在这里对您没有任何好处。

除非有任何解决办法(比如微软/打字稿#27808中的特性请求),否则就会有解决办法。

最安全的方法是实际更改函数的实现,以执行RetType<T>类型所暗示的相同的索引操作:

代码语言:javascript
复制
function fIndex<T extends Options>(arg: ArgType<T>): RetType<T> {
    return { First: 23, Second: false }[arg.type];
}

如果您真的不想预先计算不返回的值,则可以使用存取器。对于像23和false这样的值,这可能没什么大不了的,但是如果计算结果很昂贵,或者有副作用,那么getter将返回更像if/else或switch/case流的内容:

代码语言:javascript
复制
function fIndex2<T extends Options>(arg: ArgType<T>): RetType<T> {
    return {
        get First() {
            return 23;
        }, get Second() {
            return false;
        }
    }[arg.type];
}

在索引不是选项的情况下,您将不得不求助于类似类型断言的方法来告诉编译器,您正在做的事情是可以的,即使它无法验证它:

代码语言:javascript
复制
function fAssert<T extends Options>(arg: ArgType<T>): RetType<T> {
    if (arg.type === "First") {
        return 23 as RetType<T>;
    } else {
        return false as RetType<T>;
    }
}

类似的解决方法是使用调用方可以使用的单个过载签名,同时实现更宽松的签名:

代码语言:javascript
复制
function fOverload<T extends Options>(arg: ArgType<T>): RetType<T>;
function fOverload(arg: ArgType<Options>): RetType<Options> {
    if (arg.type === "First") {
        return 23;
    } else {
        return false;
    }
}

断言和重载解决方案都不像索引版本那样安全。他们会对那些与RetType<Options>无关的明显疯狂的返回类型犹豫不决。

代码语言:javascript
复制
function fBadOverloadCaught<T extends Options>(arg: ArgType<T>): RetType<T>;
function fBadOverloadCaught(arg: ArgType<Options>): RetType<Options> {
    return "whoopsie"; // error, not number | boolean
}
function fBadAssertCaught<T extends Options>(arg: ArgType<T>): RetType<T> {
    return "whoopsie" as RetType<T>; // error, not number | boolean
}

但是当你在错误的情况下返回正确的类型时,它们不会发现问题:

代码语言:javascript
复制
function fBadOverloadMissed<T extends Options>(arg: ArgType<T>): RetType<T>;
function fBadOverloadMissed(arg: ArgType<Options>): RetType<Options> {
    return (arg.type === "First") ? false : 23; // no error but reversed output
}
function fBadAssertMissed<T extends Options>(arg: ArgType<T>): RetType<T> {
    return ((arg.type === "First") ? false : 23) as RetType<T>; // no error but reversed output
}

所以你应该小心点。

操场链接到代码

票数 1
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/60461424

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档