我想编写一个函数,其返回类型取决于它的参数类型。下面是我试过的。
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>类型的函数发布于 2020-02-29 20:12:32
这是TypeScript中已知的一个痛点;有关讨论,请参见微软/打字稿#13995和微软/打字稿#24085。在以下代码中:
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 ):
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>类型所暗示的相同的索引操作:
function fIndex<T extends Options>(arg: ArgType<T>): RetType<T> {
return { First: 23, Second: false }[arg.type];
}如果您真的不想预先计算不返回的值,则可以使用存取器。对于像23和false这样的值,这可能没什么大不了的,但是如果计算结果很昂贵,或者有副作用,那么getter将返回更像if/else或switch/case流的内容:
function fIndex2<T extends Options>(arg: ArgType<T>): RetType<T> {
return {
get First() {
return 23;
}, get Second() {
return false;
}
}[arg.type];
}在索引不是选项的情况下,您将不得不求助于类似类型断言的方法来告诉编译器,您正在做的事情是可以的,即使它无法验证它:
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>;
}
}类似的解决方法是使用调用方可以使用的单个过载签名,同时实现更宽松的签名:
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>无关的明显疯狂的返回类型犹豫不决。
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
}但是当你在错误的情况下返回正确的类型时,它们不会发现问题:
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
}所以你应该小心点。
https://stackoverflow.com/questions/60461424
复制相似问题