TypeScript嵌套箭头函数根据参数返回正确类型的问题

我写了一个根据参数返回不同嵌套箭头函数的函数，但调用时TypeScript总是推断出联合类型，而不是对应参数的具体类型：

原代码 #

type Exist_Options = "true" | "ignore"

const string_parser = (o:Exist_Options) =>{
  switch (o) {
    case "true":
      return (v?:string) => {
        if (!v) {
          return true;
        }
        return v;
      };
    case "ignore":
      return (v?:string)=> {
        if (!v) {
          return null;
        }
        return v;
     };
  }
};

预期类型 #

// 传入"true"时的返回类型
type Key_Parser_ST = { (v: string | undefined): string | true};
// 传入"ignore"时的返回类型
type Key_Parser_SN = { (v: string | undefined): string | null};

当前问题 #

调用const string_parse = string_parser("true")时，TypeScript推断的类型是联合类型：((v?: string | undefined) => string | true) | ((v?: string | undefined) => string | null)，但期望得到的是对应"true"的具体类型(v?: string | undefined) => string | true。

解决方案1：函数重载 #

通过定义函数重载签名，让TypeScript根据传入的参数值匹配对应的返回类型：

type Exist_Options = "true" | "ignore";

type Key_Parser_ST = (v?: string) => string | true;
type Key_Parser_SN = (v?: string) => string | null;

// 重载签名：定义不同参数对应的返回类型
function string_parser(o: "true"): Key_Parser_ST;
function string_parser(o: "ignore"): Key_Parser_SN;

// 函数实现
function string_parser(o: Exist_Options) {
  switch (o) {
    case "true":
      return (v?: string) => {
        if (!v) return true;
        return v;
      };
    case "ignore":
      return (v?: string) => {
        if (!v) return null;
        return v;
      };
  }
}

// 现在类型推断正确
const string_parse_true = string_parser("true"); // 类型为Key_Parser_ST
const string_parse_ignore = string_parser("ignore"); // 类型为Key_Parser_SN

解决方案2：泛型+条件类型 #

用泛型约束参数类型，结合条件类型动态推导返回类型：

type Exist_Options = "true" | "ignore";

// 根据参数类型定义对应的返回类型
type ParserReturn<T extends Exist_Options> = 
  T extends "true" ? (v?: string) => string | true :
  T extends "ignore" ? (v?: string) => string | null :
  never;

const string_parser = <T extends Exist_Options>(o: T): ParserReturn<T> => {
  switch (o) {
    case "true":
      return ((v?: string) => {
        if (!v) return true;
        return v;
      }) as ParserReturn<T>;
    case "ignore":
      return ((v?: string) => {
        if (!v) return null;
        return v;
      }) as ParserReturn<T>;
    default:
      throw new Error("无效的选项");
  }
};

// 类型推断正确
const string_parse_true = string_parser("true"); // (v?: string | undefined) => string | true
const string_parse_ignore = string_parser("ignore"); // (v?: string | undefined) => string | null

原理说明 #

原代码中TypeScript会把函数的返回值推断为所有分支返回类型的联合，因为它无法自动关联输入参数和返回值的对应关系。通过重载或泛型条件类型，我们明确告诉TypeScript：当传入特定参数值时，返回对应的具体类型，从而实现精确的类型推断。

内容的提问来源于stack exchange，提问作者mimi