遍历对象时如何断言类型匹配？解决TypeScript中同类型属性操作的类型错误

这确实是TypeScript类型系统里一个挺常见的痛点——咱们明明知道遍历的键对应的两个属性类型完全匹配，但TS就是没法自动推导出来，反而抛出让人困惑的错误。咱们先拆解问题本质，再逐个场景给出解决方案。

一、原始可变场景：为什么会出现never类型错误？ #

先看你的第一个例子：

interface IMixed { a: number; b: string; c: boolean; }
const foo: IMixed = { a: 1, b: 'one', c: true };
const bar: IMixed = { a: 2, b: 'two', c: false };

(Object.keys(foo) as Array<keyof IMixed>).forEach(k => {
  foo[k] = bar[k]; // 错误：Type 'string | number | boolean' is not assignable to type 'never'.
});

错误原因： #

当k是keyof IMixed（也就是'a' | 'b' | 'c'）这种联合类型时，TS会把foo[k]的类型推断为number | string | boolean，而赋值操作要求每个位置只能接受对应精确类型：

• 当k是'a'时，foo[k]只能是number
• 当k是'b'时，foo[k]只能是string
• 当k是'c'时，foo[k]只能是boolean

但TS没法在遍历过程中把k的类型窄化到单个成员，所以它会取所有可能类型的交集——而number、string、boolean这三个类型没有任何交集，因此交集就是never，这就是错误信息里出现never的原因。

解决方案：用泛型锁定单个键的类型 #

我们可以写一个小型泛型函数，帮TS把k的类型固定为联合类型中的单个成员，这样TS就能明确知道foo[k]和bar[k]的类型完全匹配：

interface IMixed { a: number; b: string; c: boolean; }
const foo: IMixed = { a: 1, b: 'one', c: true };
const bar: IMixed = { a: 2, b: 'two', c: false };

// 泛型函数：锁定键的具体类型，让TS能推导属性类型一致
function assignMatchingKey<K extends keyof IMixed>(target: IMixed, key: K, source: IMixed) {
  target[key] = source[key];
}

(Object.keys(foo) as Array<keyof IMixed>).forEach(k => {
  assignMatchingKey(foo, k, bar); // 无错误
});

如果你不想额外写函数，也可以直接用类型断言（不过泛型方案更优雅）：

(Object.keys(foo) as Array<keyof IMixed>).forEach(k => {
  foo[k] = bar[k] as IMixed[typeof k];
});

二、更新后的不可变场景：处理泛型函数的参数匹配问题 #

再看你的第二个例子，核心问题还是一样的——TS没法知道foo[elem]和bar[elem]是同一个类型的数组，所以把它们当成了联合类型，导致intersection函数报错：

interface IMixed { a: number[]; b: string[]; c: boolean[]; }
const foo: IMixed = { a: [1], b: ['one'], c: [true] };
const bar: IMixed = { a: [2], b: ['two'], c: [false] };

function intersection<T>(...arrays: T[][]): T[] {
  return [...new Set([].concat(...arrays))];
}

(Object.keys(foo) as Array<keyof IMixed>)
  .reduce((acc, elem) => ({
    ...acc,
    [elem]: intersection(foo[elem], bar[elem]) // 错误：参数类型不兼容
  }), foo);

解决方案：同样用泛型锁定类型 #

还是用泛型函数来包裹单个键的处理逻辑，让TS能推导出两个数组的类型一致：

interface IMixed { a: number[]; b: string[]; c: boolean[]; }
const foo: IMixed = { a: [1], b: ['one'], c: [true] };
const bar: IMixed = { a: [2], b: ['two'], c: [false] };

function intersection<T>(...arrays: T[][]): T[] {
  return [...new Set([].concat(...arrays))];
}

// 泛型函数：处理单个键的交集计算
function computeKeyIntersection<K extends keyof IMixed>(obj1: IMixed, obj2: IMixed, key: K) {
  return intersection(obj1[key], obj2[key]);
}

const result = (Object.keys(foo) as Array<keyof IMixed>)
  .reduce((acc, elem) => ({
    ...acc,
    [elem]: computeKeyIntersection(foo, bar, elem)
  }), foo);

当然，也可以直接在reduce里用类型断言，但泛型方案更具可读性和可维护性：

const result = (Object.keys(foo) as Array<keyof IMixed>)
  .reduce((acc, elem) => ({
    ...acc,
    [elem]: intersection(foo[elem] as IMixed[typeof elem], bar[elem] as IMixed[typeof elem])
  }), foo);

总结 #

这类问题的核心都是TypeScript无法自动窄化联合类型的遍历键到单个成员，导致它只能看到所有可能类型的联合/交集。解决思路就是通过泛型函数主动帮TS锁定键的具体类型，让它能推导出对应属性的类型一致性——这比直接用any或unknown断言更安全，也更符合TypeScript的类型系统设计。

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