TypeScript：嵌套接口的合并/覆写及深层对象转换问题

这问题我太熟了！刚好有几个既保证TypeScript类型安全、又不破坏上层结构的方案，给你详细说说：

核心思路是只修改最深层的Level3对象，上层结构通过不可变方式保留原有属性，下面分三种场景给出具体实现：

方案1：手动递归+不可变更新（无依赖，适合固定层级） #

如果你的嵌套层级固定（就像现在的3层结构），直接手动遍历每一层，用对象展开运算符...保留未修改的属性，只替换需要转换的深层对象：

import { Level1, Level2, Level3 } from './your-interfaces';

// 定义最深层Level3的转换逻辑（这里示例是转大写，你可以换成自己的逻辑）
const transformLevel3 = (item: Level3): Level3 => {
  return {
    e3: item.e3.toUpperCase(),
    f3: item.f3.toUpperCase()
  };
};

// 递归处理整个嵌套结构
const transformNestedObject = (data: Level1): Level1 => {
  return {
    ...data, // 完全保留Level1的a1属性
    b1: data.b1.map((level2: Level2) => ({
      ...level2, // 完全保留Level2的c2属性
      d2: level2.d2.map(transformLevel3) // 转换每个Level3对象
    }))
  };
};

// 使用示例
const originalData: Level1 = { 
  a1: 'foo1', 
  b1: [ { c2: 'foo2', d2: [ { e3: 'foo3', f3: 'foo3' }, { e3: 'bar3', f3: 'bar3' } ] } ] 
};

const transformedData = transformNestedObject(originalData);

优点 #

• 零外部依赖，代码完全可控
• TypeScript类型检查全程覆盖，不会出现类型错误
• 逻辑清晰，上层属性的保留一目了然

方案2：用Immer简化不可变操作（简洁直观，适合复杂层级） #

如果以后嵌套层级变深，手动展开会很繁琐，推荐用immer库——它允许你用"可变"的写法实现不可变更新，底层自动帮你生成新对象，上层未修改的结构会自动保留：

首先安装依赖：

npm install immer
# 或者 yarn add immer

然后实现转换：

import { produce } from 'immer';
import { Level1 } from './your-interfaces';

const originalData: Level1 = { 
  a1: 'foo1', 
  b1: [ { c2: 'foo2', d2: [ { e3: 'foo3', f3: 'foo3' }, { e3: 'bar3', f3: 'bar3' } ] } ] 
};

const transformedData = produce(originalData, (draft) => {
  // 直接遍历修改draft对象，Immer会自动处理不可变逻辑
  draft.b1.forEach(level2 => {
    level2.d2.forEach(level3 => {
      level3.e3 = level3.e3.toUpperCase();
      level3.f3 = level3.f3.toUpperCase();
    });
  });
});

优点 #

• 代码极度简洁，不需要手动写对象展开
• 即使层级再深，写法依然直观
• 完全兼容TypeScript，类型推断自动生效

方案3：通用递归转换器（复用性强，适合动态结构） #

如果你的嵌套结构不固定，或者需要把转换逻辑复用在其他嵌套对象上，可以写一个通用的递归转换函数，通过类型守卫识别目标层级：

import { Level1, Level3 } from './your-interfaces';

// 定义通用转换函数类型
type TransformFn<T> = (item: T) => T;

const deepTransform = <T>(
  data: T,
  targetTypeGuard: (item: any) => boolean,
  transformFn: TransformFn<any>
): T => {
  // 处理数组：遍历每个元素递归转换
  if (Array.isArray(data)) {
    return data.map(item => deepTransform(item, targetTypeGuard, transformFn)) as T;
  }
  // 处理对象：先判断是否是目标类型
  if (typeof data === 'object' && data !== null) {
    if (targetTypeGuard(data)) {
      return transformFn(data) as T;
    }
    // 非目标类型则遍历所有属性递归转换
    return Object.fromEntries(
      Object.entries(data).map(([key, value]) => [key, deepTransform(value, targetTypeGuard, transformFn)])
    ) as T;
  }
  // 基本类型直接返回
  return data;
};

// 定义Level3的类型守卫，用于识别目标层级
const isLevel3 = (item: any): item is Level3 => {
  return typeof item === 'object' && item !== null && 'e3' in item && 'f3' in item;
};

// 定义Level3的转换逻辑
const transformLevel3 = (item: Level3): Level3 => ({
  e3: item.e3.toUpperCase(),
  f3: item.f3.toUpperCase()
});

// 使用示例
const transformedData = deepTransform(originalData, isLevel3, transformLevel3);

优点 #

• 完全通用，只要传入类型守卫和转换函数，就能处理任意嵌套结构
• 复用性极强，同一个函数可以转换不同类型的深层对象

• 固定浅层级：优先用方案1，无依赖且直观
• 复杂深层级：优先用方案2，Immer大幅简化代码
• 需要复用转换逻辑：用方案3，一次编写多处使用

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