TypeScript如何从Enum中排除指定项并合并其他枚举？

看起来你想要的是在类型层面合并多个枚举的特定成员，同时保留原有枚举的直接访问方式，不用切换枚举归属来调用成员，还要处理同名枚举成员的冲突场景。下面针对TypeScript场景给出具体解决方案（核心逻辑适配其他支持枚举的语言）：

1. 先明确现有枚举结构（模拟你的场景） #

假设你已经定义了这些枚举：

// 基础API状态枚举，包含成功状态Ok和其他错误码
enum Errcode {
  Ok = 0,
  InvalidParam = 1,
  TagNotFound = 2,
  PermissionDenied = 3
}

// 未找到类错误枚举
enum NotFoundError {
  TagNotFound = 2, // 和Errcode.TagNotFound同值
  UserNotFound = 4,
  PostNotFound = 5
}

// 标签相关错误枚举（模拟同名不同值的冲突场景）
enum TagErrcode {
  TagNotFound = 6, // 和Errcode.TagNotFound不同值
  TagDuplicate = 7
}

2. 类型层面：定义ErrorErrcode类型 #

用Exclude排除Errcode.Ok，再和其他错误枚举做联合类型，这样类型就包含了你需要的所有错误码：

// 排除Errcode.Ok，联合NotFoundError和TagErrcode的所有成员
type ErrorErrcode = Exclude<Errcode, Errcode.Ok> | NotFoundError | TagErrcode;

这个类型会自动覆盖：

• Errcode中除了Ok的所有值（1、2、3）
• NotFoundError的所有值（2、4、5）
• TagErrcode的所有值（6、7）
  即使有同名成员（比如TagNotFound），值相同会被合并为同一类型，值不同则会保留各自的类型区分。

3. 值层面：保留原有枚举的直接访问 #

你担心的“必须知晓归属”问题，在值层面完全不需要改变调用习惯——你依然可以直接写Errcode.InvalidParam、Errcode.TagNotFound、NotFoundError.UserNotFound，这些值都会被ErrorErrcode类型接受，类型检查完全通过。

比如你可以这样使用：

function handleError(code: ErrorErrcode) {
  switch(code) {
    case Errcode.InvalidParam:
      console.log("参数错误");
      break;
    case Errcode.TagNotFound: // 对应值2
      console.log("标签不存在（基础枚举）");
      break;
    case TagErrcode.TagNotFound: // 对应值6
      console.log("标签不存在（标签专属枚举）");
      break;
    case NotFoundError.UserNotFound:
      console.log("用户不存在");
      break;
    // ...其他错误处理
  }
}

// 调用时直接用原有枚举成员，完全不用改
handleError(Errcode.PermissionDenied);
handleError(NotFoundError.PostNotFound);
handleError(TagErrcode.TagDuplicate);

4. 处理同名不同值的冲突（可选优化） #

如果觉得同名成员容易混淆，可以创建一个统一的访问对象，自动给冲突成员加前缀区分：

// 创建统一的错误码访问对象，自动处理同名冲突
const ErrorErrcode = {
  // 导入Errcode排除Ok的成员
  ...Object.fromEntries(
    Object.entries(Errcode).filter(([key]) => key !== "Ok")
  ),
  // 导入NotFoundError的成员，若和Errcode同名且值不同则加前缀
  ...Object.fromEntries(
    Object.entries(NotFoundError).map(([key, value]) => {
      if (key in Errcode && Errcode[key as keyof typeof Errcode] !== value) {
        return [`NotFound${key}`, value];
      }
      return [key, value];
    })
  ),
  // 导入TagErrcode的成员，同理处理冲突
  ...Object.fromEntries(
    Object.entries(TagErrcode).map(([key, value]) => {
      if (key in Errcode && Errcode[key as keyof typeof Errcode] !== value) {
        return [`Tag${key}`, value];
      }
      return [key, value];
    })
  )
} as const;

// 从对象推导对应的类型
type ErrorErrcodeType = typeof ErrorErrcode[keyof typeof ErrorErrcode];

// 使用示例
handleError(ErrorErrcode.InvalidParam);
handleError(ErrorErrcode.TagNotFound); // 对应值2
handleError(ErrorErrcode.TagTagNotFound); // 对应值6，自动加了前缀

这样既满足了类型需求，又保留了你习惯的调用方式，还处理了同名冲突的场景。

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