TypeScript中const断言对象字面量的值检查最佳实践咨询

先看你给出的两个类型守卫实现：

const ObjectLiteral = {
    A: 'a',
    B: 'b',
    C: 'c'
} as const;

type ObjectLiteral = typeof ObjectLiteral[keyof typeof ObjectLiteral]

const isObjectLiteralValue1 = (val: string): val is ObjectLiteral => {
    return Object.values(ObjectLiteral).includes(val as ObjectLiteral)
}

const isObjectLiteralValue2 = (val: string): val is ObjectLiteral => {
    const list = Object.values(ObjectLiteral) as string[];
    return list.includes(val)
}

两种实现的对比 #

这两个函数运行时效果完全一致，都是判断输入字符串是否属于ObjectLiteral的值集合，但类型处理逻辑有明显区别：

• isObjectLiteralValue1：因为ObjectLiteral加了as const断言，Object.values返回的是只读元组readonly ["a", "b", "c"]，includes方法的参数类型被严格限制为元组成员（也就是ObjectLiteral类型），所以需要把输入的val断言为ObjectLiteral才能通过TypeScript的类型检查。这种写法保留了const断言带来的精确类型约束，没有放宽类型范围。
• isObjectLiteralValue2：把Object.values的结果断言成string[]，相当于放弃了原有的元组精确类型，换成了更宽泛的字符串数组。虽然不用断言输入值，但本质上是降低了类型检查的严谨性。

两者没有本质优劣，若要二选一更推荐isObjectLiteralValue1，因为它贴合const断言的类型精确性设计初衷。

更优的实现方式 #

根据不同场景，有几种更实用的写法：

1. 预存值数组，避免重复计算 #

每次调用类型守卫都执行Object.values会产生微小的性能损耗，尤其是频繁调用时。可以提前提取值集合：

const ObjectLiteral = {
    A: 'a',
    B: 'b',
    C: 'c'
} as const;

type ObjectLiteral = typeof ObjectLiteral[keyof typeof ObjectLiteral];
// 预存值数组，用const断言保留精确类型
const ObjectLiteralValues = Object.values(ObjectLiteral) as const;

const isObjectLiteralValue = (val: string): val is ObjectLiteral => {
    return ObjectLiteralValues.includes(val as ObjectLiteral);
};

2. 使用Set提升查找效率（值数量较多时更明显） #

如果对象中的值数量较多，Set.prototype.has的查找效率远高于数组includes（时间复杂度O(1) vs O(n)）：

const ObjectLiteral = {
    A: 'a',
    B: 'b',
    C: 'c'
} as const;

type ObjectLiteral = typeof ObjectLiteral[keyof typeof ObjectLiteral];
const ObjectLiteralValueSet = new Set(Object.values(ObjectLiteral));

const isObjectLiteralValue = (val: string): val is ObjectLiteral => {
    return ObjectLiteralValueSet.has(val as ObjectLiteral);
};

3. 完全无断言的写法（极致类型安全） #

要是想彻底摆脱类型断言，可以借助switch分支实现类型收窄，缺点是对象新增属性时需要手动更新分支：

const ObjectLiteral = {
    A: 'a',
    B: 'b',
    C: 'c'
} as const;

type ObjectLiteral = typeof ObjectLiteral[keyof typeof ObjectLiteral];

const isObjectLiteralValue = (val: string): val is ObjectLiteral => {
    switch (val) {
        case ObjectLiteral.A:
        case ObjectLiteral.B:
        case ObjectLiteral.C:
            return true;
        default:
            return false;
    }
};

总结 #

• 你的两个原有实现都可行，优先选isObjectLiteralValue1以保留类型精确性
• 日常开发推荐预存值数组的写法，兼顾性能和类型严谨性
• 值数量较多时，优先用Set提升查找效率
• 追求极致类型安全且对象属性稳定时，考虑switch分支的写法

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