TypeScript中实现基于参数的条件返回类型函数

interface IdLabel {
  id: number;
  // ... 其他字段
}
interface NameLabel {
  name: string;
  // ... 其他字段
}

// 定义一个条件类型，根据T是number还是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') {
    // 预期当idOrName是number时，返回IdLabel
    return { id: idOrName }; // 报错：Type '{ id: number; }' is not assignable to type 'NameOrId<T>'.
  } else {
    // 预期当idOrName是string时，返回NameLabel
    return { name: idOrName }; // 报错：Type '{ name: string; }' is not assignable to type 'NameOrId<T>'.
  }
}

type GetResult = {
  getData: string;
}

type PostResult = {
  postData: string;
}

// 映射操作名称到其结果类型
type ResultType = {
  get: GetResult;
  post: PostResult;
  // ... 更多操作
}

/**
 * 根据操作名称返回不同类型结果的函数
 * @param operation 操作名称，必须是ResultType的键
 * @returns 对应操作的结果类型
 */
function fn<T extends keyof ResultType>(operation: T): ResultType[T] {
  if (operation === "get") {
    // 在此处进行类型断言，告诉TypeScript这个返回值是ResultType[T]
    return { getData: "foo" } as ResultType[T];
  } else if (operation === "post") {
    // 同理，进行类型断言
    return { postData: "bar" } as ResultType[T];
  } else {
    // 处理其他或未知操作，这里简化为抛出错误或返回默认值
    throw new Error(`Unsupported operation: ${operation}`);
  }
}

// 调用示例
const res1 = fn("get"); // res1 的类型被推断为 GetResult
console.log(res1.getData);

const res2 = fn("post"); // res2 的类型被推断为 PostResult
console.log(res2.postData);

// const res3 = fn("put"); // 编译错误：Argument of type '"put"' is not assignable to parameter of type '"get" | "post"'.

type GetResult = {
  getData: string;
}
type PostResult = {
  postData: string;
}

// 1. 定义一个包含所有操作实现的对象
const _operations = {
  get(): GetResult {
    return { getData: "foo" };
  },
  post(): PostResult {
    return { postData: "bar" };
  },
  // ... 更多操作
};

// 2. 从 _operations 对象中派生出 ResultType
// 遍历 _operations 的所有键，并获取对应函数的返回值类型
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 fn<T extends keyof ResultType>(operation: T): ResultType[T] {
  return operations[operation]();
}

// 调用示例
const resA = fn("get"); // resA 的类型被推断为 GetResult
console.log(resA.getData);

const resB = fn("post"); // resB 的类型被推断为 PostResult
console.log(resB.postData);

// const resC = fn("delete"); // 编译错误：Argument of type '"delete"' is not assignable to parameter of type '"get" | "post"'.