TypeScript中实现基于参数的动态返回类型：从条件类型到类型安全函数映射

interface IdLabel {
  id: number /* + 其他字段 */
}
interface NameLabel {
  name: string /* + 其他字段 */
}

type NameOrId<T extends number | string> = T extends number ? IdLabel : NameLabel

function createLabel<T extends number | string>(idOrName: T): NameOrId<T> {
  if (typeof idOrName === 'number') {
    // 错误：Type '{ id: number; }' is not assignable to type 'NameOrId<T>'.
    return { id: idOrName }
  } else {
    // 错误：Type '{ name: string; }' is not assignable to type 'NameOrId<T>'.
    return { name: idOrName }
  }
}

// 定义不同的返回结果类型
type GetResult = {
  getData: string;
}

type PostResult = {
  postData: string;
}

// 定义操作名称到返回类型的映射
type ResultType = {
  get: GetResult;
  post: PostResult;
}

/**
 * 根据操作类型返回不同结果的函数
 * @param operation 操作名称，必须是 ResultType 的键
 * @returns 对应操作的返回类型
 */
function processOperation<T extends keyof ResultType>(operation: T): ResultType[T] {
  if (operation === "get") {
    // 使用类型断言告知编译器当前返回值的类型
    return { getData: "获取数据成功" } as ResultType[T];
  } else {
    // 同样使用类型断言
    return { postData: "提交数据成功" } as ResultType[T];
  }
}

// 测试函数，观察返回类型的自动推断
const getRes = processOperation("get");
//    ^? getRes: GetResult
console.log(getRes.getData); // 访问 GetResult 的属性

const postRes = processOperation("post");
//    ^? postRes: PostResult
console.log(postRes.postData); // 访问 PostResult 的属性

// 尝试传入不存在的操作，会得到编译错误
// const putRes = processOperation("put");
//                                ^^^^^ Argument of type '"put"' is not assignable to parameter of type '"get" | "post"'.

// 定义不同的返回结果类型
type GetResult = {
  getData: string;
}
type PostResult = {
  postData: string;
}

// 1. 定义内部操作实现对象
// 这里的每个函数都明确返回其类型，TypeScript会进行推断
const _operations = {
  get(): GetResult {
    return { getData: "获取数据成功" };
  },
  post(): PostResult {
    return { postData: "提交数据成功" };
  },
  // 可以添加更多操作...
  delete(): { success: boolean } {
    return { success: true };
  }
};

// 2. 从 _operations 派生出 ResultType
// ResultType 会自动变为 { get: GetResult; post: PostResult; delete: { success: boolean } }
type ResultType = {
  [key in keyof typeof _operations]: ReturnType<(typeof _operations)[key]>;
}

// 3. 定义一个公开的 operations 对象，并使用 ResultType 进行类型注解
// 这确保了 _operations 的结构与 ResultType 保持一致，并提供了类型安全
const operations: { [K in keyof ResultType]: () => ResultType[K] } = _operations;

/**
 * 根据操作类型返回不同结果的函数 (完全类型安全版本)
 * @param operation 操作名称，必须是 ResultType 的键
 * @returns 对应操作的返回类型
 */
function processOperationSafe<T extends keyof ResultType>(operation: T): ResultType[T] {
  // 直接调用对应的操作函数，无需类型断言
  return operations[operation]();
}

// 测试函数，观察返回类型的自动推断
const getResSafe = processOperationSafe("get");
//    ^? getResSafe: GetResult
console.log(getResSafe.getData);

const postResSafe = processOperationSafe("post");
//    ^? postResSafe: PostResult
console.log(postResSafe.postData);

const deleteResSafe = processOperationSafe("delete");
//    ^? deleteResSafe: { success: boolean }
console.log(deleteResSafe.success);

// 尝试传入不存在的操作，同样会得到编译错误
// const updateResSafe = processOperationSafe("update");
//                                          ^^^^^^^^ Argument of type '"update"' is not assignable to parameter of type '"get" | "post" | "delete"'.