TypeScript枚举的扩展与继承：无额外类型结构的实现方案问询

我想知道，对于存在依赖关系的枚举，有没有一种不需要借助额外类型结构来“粘合”它们的实现模式？

现有代码示例 #

enum FruitEnum {
    Apple = "APPLE",
    Orange = "ORANGE"
}

// 期望 DesertEnum 继承 FruitEnum
enum DesertEnum {
    Apple = FruitEnum.Apple,
    Orange = FruitEnum.Orange,
    CheeseCake = "CHEESE_CAKE",
    ChocolateCake = "CHOCOLATE_CAKE",
    Pie = "PIE"
}

// 期望 CakeEnum 继承 DesertEnum
enum CakeEnum {
    CheeseCake = DesertEnum.CheeseCake,
    ChocolateCake = DesertEnum.ChocolateCake
}

/*
    类型错误：'DesertEnum.Pie | CakeEnum' 无法赋值给类型 'DesertsEnum'。
    类型 'CakeEnum.CheeseCake' 无法赋值给类型 'DesertsEnum'。(2322)
*/
const whichCake: DesertEnum = Object.values(CakeEnum)
                                    .find(cake => cake === CakeEnum.ChocolateCake) ?? DesertEnum.Pie

/*
    类型错误：'FruitEnum | DesertsEnum.Pie' 无法赋值给类型 'DesertsEnum'。
    类型 'FruitEnum.Apple' 无法赋值给类型 'DesertsEnum'。(2322)
*/
const whichFruit: DesertEnum = Object.values(FruitEnum)
                                     .find(fruit => fruit === FruitEnum.Apple) ?? DesertEnum.Pie

我尝试过的方案（但觉得冗余易出错） #

// 感觉这是个权宜之计，类型应该能通过某种模式自动推断出来。
// 如果新增一种甜点类型，既要创建枚举，还要手动加到 DesertsType 里，很麻烦。

type DesertsType = FruitEnum | CakeEnum | DesertEnum

解决方案：利用类型推断与枚举值的类型兼容性 #

TypeScript 里的枚举本质上是值的集合，不存在真正的继承关系——你当前的写法只是把其他枚举的值复制过来，但类型系统不会自动识别它们的兼容关系。要实现无额外粘合类型的效果，可以从以下几个方向入手：

1. 用类型别名自动推导兼容类型

不需要手动拼接联合类型，直接通过typeof推导依赖枚举的类型，让 TypeScript 自动识别值的兼容性：

// 自动推导 DesertEnum 的兼容类型：包含 FruitEnum 和自身的所有值
type DesertCompatible = typeof FruitEnum[keyof typeof FruitEnum] | typeof DesertEnum[keyof typeof DesertEnum];

// 使用推导类型替代手动拼接的 DesertsType
const whichCake: DesertCompatible = Object.values(CakeEnum)
                                    .find(cake => cake === CakeEnum.ChocolateCake) ?? DesertEnum.Pie;

const whichFruit: DesertCompatible = Object.values(FruitEnum)
                                     .find(fruit => fruit === FruitEnum.Apple) ?? DesertEnum.Pie;

这种方式的好处是，当你给FruitEnum或DesertEnum新增值时，DesertCompatible会自动更新，不需要手动维护。

2. 用字符串字面量类型替代枚举（更灵活的方案）

如果你的枚举都是字符串值，完全可以用字符串字面量类型和对象模拟枚举，天然支持类型兼容：

// 定义字面量类型
type Fruit = "APPLE" | "ORANGE";
type Desert = Fruit | "CHEESE_CAKE" | "CHOCOLATE_CAKE" | "PIE";
type Cake = "CHEESE_CAKE" | "CHOCOLATE_CAKE";

// 模拟枚举的常量对象
const FruitEnum = {
    Apple: "APPLE" as Fruit,
    Orange: "ORANGE" as Fruit
};

const DesertEnum = {
    ...FruitEnum,
    CheeseCake: "CHEESE_CAKE" as Desert,
    ChocolateCake: "CHOCOLATE_CAKE" as Desert,
    Pie: "PIE" as Desert
};

const CakeEnum = {
    CheeseCake: DesertEnum.CheeseCake,
    ChocolateCake: DesertEnum.ChocolateCake
};

// 类型兼容完全自动，不会报错
const whichCake: Desert = Object.values(CakeEnum)
                                    .find(cake => cake === CakeEnum.ChocolateCake) ?? DesertEnum.Pie;

const whichFruit: Desert = Object.values(FruitEnum)
                                     .find(fruit => fruit === FruitEnum.Apple) ?? DesertEnum.Pie;

这种方案彻底避免了枚举的类型兼容问题，字面量类型天然支持子集扩展，对象扩展语法也能轻松实现值的复用。

3. 类型断言快速修复现有代码

如果不想改动现有枚举结构，也可以在赋值时用类型断言跳过类型检查（适合临时场景）：

const whichCake: DesertEnum = (Object.values(CakeEnum)
                                    .find(cake => cake === CakeEnum.ChocolateCake) ?? DesertEnum.Pie) as DesertEnum;

const whichFruit: DesertEnum = (Object.values(FruitEnum)
                                     .find(fruit => fruit === FruitEnum.Apple) ?? DesertEnum.Pie) as DesertEnum;

但这种方式不推荐长期使用，因为它绕过了类型系统的检查，新增值时容易出现遗漏。

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