TypeScript中如何声明动态键泛型对象的值类型？

嘿，这个问题在TypeScript里其实用泛型加映射类型就能完美解决，我分两种常见场景给你讲清楚：

1. 基础场景：只约束键和值的类型（不严格校验数组长度） #

如果你的核心需求是确保对象的键来自数组A的元素类型、值来自数组B的数值类型，而暂时不强制校验两个数组的长度是否一致，可以用Record泛型结合函数泛型来实现：

function createKeyValueObject<K extends PropertyKey, V extends number>(
  keys: K[],
  values: V[]
): Record<K, V> {
  const result: Partial<Record<K, V>> = {};
  // 建议加个运行时校验，防止数组长度不一致导致数据丢失
  if (keys.length !== values.length) {
    throw new Error("两个数组长度必须相同！");
  }
  for (let i = 0; i < keys.length; i++) {
    result[keys[i]] = values[i];
  }
  return result as Record<K, V>;
}

代码解释： #

• K extends PropertyKey：确保键是合法的对象键类型（string、number、symbol）；
• V extends number：约束值为数值类型，对应你的数组B；
• Record<K, V>：这就是我们要的对象类型，表示所有键都是K类型，所有值都是V类型的对象；
• 用Partial<Record<K, V>>临时存储结果，最后断言为完整类型（因为已经做了长度校验）。

使用示例： #

const keys = ['username', 'age', 'score'] as const;
const values = [28, 95, 88];
const userInfo = createKeyValueObject(keys, values);
// userInfo的类型是：Record<'username' | 'age' | 'score', number>

2. 严格场景：强制两个数组长度相同（编译时校验） #

如果希望在编译阶段就阻止长度不一致的数组传入，可以通过元组泛型实现更严格的类型约束：

// 类型定义部分
function createStrictKeyValueObject<
  Keys extends readonly PropertyKey[],
  Values extends readonly number[]
>(
  keys: Keys,
  // 约束Values的长度和Keys完全一致，且每个元素都是number
  values: Values extends { [Index in keyof Keys]: number } ? Values : never
): {
  // 把元组的每个键值对映射成对象属性
  [Index in keyof Keys]: { [Key in Keys[Index]]: Values[Index] }
}[number] extends infer MergedObj
  ? { [Key in keyof MergedObj]: MergedObj[Key] }
  : never;

// 实现部分
function createStrictKeyValueObject(keys: PropertyKey[], values: number[]) {
  const result: Record<PropertyKey, number> = {};
  for (let i = 0; i < keys.length; i++) {
    result[keys[i]] = values[i];
  }
  return result;
}

代码解释： #

• 通过Keys extends readonly PropertyKey[]把keys推断成只读元组类型，让TypeScript捕获到具体的键名和长度；
• Values extends { [Index in keyof Keys]: number }强制Values的长度和Keys完全匹配，且每个元素都是number；
• 返回类型通过映射元组的每个索引，把键值对合并成一个完整的对象类型。

使用示例： #

// 正常情况：类型完全匹配
const strictObj = createStrictKeyValueObject(['id', 'price'] as const, [1001, 99.9]);
// strictObj的类型是：{ id: number; price: number }

// 错误情况：数组长度不一致，编译时直接报错
createStrictKeyValueObject(['a', 'b'] as const, [1]);

3. 动态键场景：编译时未知具体键名 #

如果数组A是动态生成的（比如从后端接口获取），编译时无法知道具体的键名，那最适合的类型就是Record<PropertyKey, number>（或者更具体的Record<string, number>如果确定键都是字符串）：

function createDynamicObject(keys: string[], values: number[]): Record<string, number> {
  const result: Record<string, number> = {};
  if (keys.length !== values.length) throw new Error("长度不匹配");
  for (let i = 0; i < keys.length; i++) {
    result[keys[i]] = values[i];
  }
  return result;
}

这个时候TypeScript无法推断出具体的键名，只能保证所有值都是number类型。

总结一下：

• 如果能确定键的具体值（比如用as const断言数组），用泛型+Record或严格元组映射可以得到精确的对象类型；
• 如果键是动态未知的，用Record<PropertyKey, number>就足够满足类型约束需求。

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