TypeScript中已知键的对象属性访问如何实现完全类型安全？

我有一个名为LanguageOptions的对象，其键为已知固定值：

const LanguageOptions = {
  NB: { kode: "nb", tekst: "Bokmål" },
  NN: { kode: "nn", tekst: "Nynorsk" },
  SE: { kode: "se", tekst: "Samisk" },
  EN: { kode: "en", tekst: "Engelsk" },
} satisfies Record<string, { kode: string; tekst: string }>;

我希望用字符串访问该对象，同时让TypeScript能正确推断我已经处理了字符串不在对象键集合中的所有情况。目前仅能找到两种实现方式，但都存在隐患：

• 类型断言方式：

  LanguageOptions[languageUpper as keyof typeof LanguageOptions]
  

  这种方式相当于向TypeScript“撒谎”，强行断言字符串是对象的合法键。如果实际字符串不在键集合中，会触发运行时错误，而TypeScript无法提前检测。

• 自定义类型守卫方式：

  function languageInLanguages(language: string): language is keyof typeof LanguageOptions {
    return Object.hasOwn(LanguageOptions, language);
  }
  

  若类型守卫的返回逻辑写错（比如误返回true），TypeScript不会报错，但会导致运行时问题，无法做到完全的类型安全。

我更倾向于直接用Object.hasOwn做条件判断的写法：

if (Object.hasOwn(LanguageOptions, language)) {
  const noGuard = LanguageOptions[languageUpper];
}

但这段代码会触发TypeScript错误：Element implicitly has an 'any' type because expression of type 'string' can't be used to index type。

解决方案 #

方法1：用in操作符实现自动类型缩小

TypeScript支持通过in操作符自动缩小索引类型，前提是对象的键类型被保留为字面量类型（而非被Record<string, ...>宽泛化）。

首先调整LanguageOptions的类型定义，显式保留键的字面量类型：

// 提取键的字面量类型
type LanguageKey = 'NB' | 'NN' | 'SE' | 'EN';

const LanguageOptions: Record<LanguageKey, { kode: string; tekst: string }> = {
  NB: { kode: "nb", tekst: "Bokmål" },
  NN: { kode: "nn", tekst: "Nynorsk" },
  SE: { kode: "se", tekst: "Samisk" },
  EN: { kode: "en", tekst: "Engelsk" },
};

之后直接使用in操作符做条件判断，TypeScript会自动缩小变量类型：

function getLanguageOption(language: string) {
  const languageUpper = language.toUpperCase();
  if (languageUpper in LanguageOptions) {
    // 此处languageUpper被推断为LanguageKey类型，访问完全类型安全
    const option = LanguageOptions[languageUpper];
    return option;
  }
  // 处理非法键的情况
  throw new Error(`无效的语言代码：${language}`);
}

方法2：优化类型守卫，绑定键常量与类型

通过提取对象键为常量数组，让类型守卫的逻辑完全依赖常量数组，避免逻辑写错的风险：

// 定义键的常量数组，用as const保留字面量类型
const LANGUAGE_KEYS = ['NB', 'NN', 'SE', 'EN'] as const;
// 从常量数组提取键类型
type LanguageKey = typeof LANGUAGE_KEYS[number];

const LanguageOptions = {
  NB: { kode: "nb", tekst: "Bokmål" },
  NN: { kode: "nn", tekst: "Nynorsk" },
  SE: { kode: "se", tekst: "Samisk" },
  EN: { kode: "en", tekst: "Engelsk" },
} satisfies Record<LanguageKey, { kode: string; tekst: string }>;

// 基于常量数组实现类型守卫
function isLanguageKey(language: string): language is LanguageKey {
  return (LANGUAGE_KEYS as readonly string[]).includes(language);
}

// 使用方式
function getLanguageOption(language: string) {
  const languageUpper = language.toUpperCase();
  if (isLanguageKey(languageUpper)) {
    const option = LanguageOptions[languageUpper];
    return option;
  }
  throw new Error(`无效的语言代码：${language}`);
}

后续若新增或修改键，只需同步更新LANGUAGE_KEYS，TypeScript会自动校验LanguageOptions的键是否符合类型，从根源避免不一致问题。

方法3：包装带类型谓词的Object.hasOwn

如果偏好使用Object.hasOwn，可以包装一个带类型谓词的函数，让TypeScript能识别条件判断后的类型缩小：

const LanguageOptions = {
  NB: { kode: "nb", tekst: "Bokmål" },
  NN: { kode: "nn", tekst: "Nynorsk" },
  SE: { kode: "se", tekst: "Samisk" },
  EN: { kode: "en", tekst: "Engelsk" },
} satisfies Record<string, { kode: string; tekst: string }>;

// 提取对象的键类型
type LanguageKey = keyof typeof LanguageOptions;

// 包装Object.hasOwn，添加类型谓词
function hasLanguageKey(obj: typeof LanguageOptions, key: string): key is LanguageKey {
  return Object.hasOwn(obj, key);
}

// 使用方式
function getLanguageOption(language: string) {
  const languageUpper = language.toUpperCase();
  if (hasLanguageKey(LanguageOptions, languageUpper)) {
    const option = LanguageOptions[languageUpper];
    return option;
  }
  throw new Error(`无效的语言代码：${language}`);
}

这种方式既保留了Object.hasOwn的语义，又实现了类型安全的访问。

内容的提问来源于stack exchange，提问作者Jan Greger Hemb