如何将含uid的子对象替换为其uid值？求更优实现方案

需求说明 #

给定原始JavaScript对象：

const obj = {
  uid: "893212",
  a: {name: "Down here!", uid: "1231"},
  b: {
    c: {uid: "5965"},
    name: "bud name",
  }, 
  d: {name: "doodle name"},
  e: {name: "alexa name"},
  f: ["kk", "jj"],
  g: [
   {
     h: {uid: "47895"},
     i: {uid: "4785"}
   },
   {
     j: {uid: "4895"}
   }
  ]
};

要求：若子对象中存在uid属性，则将其父对象对应属性的值替换为该uid的值，处理后的目标结果如下：

const result = {
  uid: "893212",
  a: "1231",
  b: {c: "5965", name: "bud name"},
  d: {name: "doodle name"},
  e: {name: "alexa name"},
  f: ["kk", "jj"],
  g: [
   {h: "47895", i: "4785"},
   {j: "4895"}
  ]
}

原始尝试代码 #

用户最初尝试的递归实现如下，希望能得到更简洁的写法：

const mapObj = (obj = {}) => {
  if (isObject(obj)) {
    const entries = Object.entries(obj);

    for (let i = 0; i < entries.length; i += 1) {
      const [objK, objV] = entries[i];
      
      if (isObject(objV) && 'uid' in objV) {
        obj[objK] = objV['uid'];          
      } else if(isObject(objV)){
        findNestedObject(objV);
      } else if(isArray(objV)) {
        objV.forEach(val => {
          findNestedObject(val);
        })
      }
    } 
  }
};

优化后的简洁实现 #

方案一：返回新对象（无副作用） #

这个实现同时处理对象和数组，语法更简洁，且不会修改原对象：

function transform(obj) {
  // 处理数组：递归转换每个元素
  if (Array.isArray(obj)) {
    return obj.map(transform);
  }
  // 处理非null对象
  if (typeof obj === 'object' && obj !== null) {
    return Object.fromEntries(
      Object.entries(obj).map(([key, value]) => {
        // 子对象含uid则替换为uid值，否则递归处理
        if (typeof value === 'object' && value !== null && 'uid' in value) {
          return [key, value.uid];
        }
        return [key, transform(value)];
      })
    );
  }
  // 基础类型直接返回
  return obj;
}

// 使用示例
const result = transform(obj);
console.log(result);

方案二：原地修改原对象（和原始逻辑一致） #

如果需要直接修改原对象，可使用更简洁的遍历写法：

function transformInPlace(obj) {
  if (Array.isArray(obj)) {
    obj.forEach(transformInPlace);
    return;
  }
  if (typeof obj === 'object' && obj !== null) {
    Object.entries(obj).forEach(([key, value]) => {
      if (typeof value === 'object' && value !== null && 'uid' in value) {
        obj[key] = value.uid;
      } else {
        transformInPlace(value);
      }
    });
  }
}

// 使用示例
transformInPlace(obj);
console.log(obj); // 原对象已转换为目标结果

实现说明 #

• 两种方案都能正确处理数组中的嵌套对象，递归遍历所有层级的结构。
• 用Array.isArray判断数组，用typeof obj === 'object' && obj !== null覆盖所有对象类型（包括普通对象、数组等，但数组已经提前判断）。
• 利用Object.entries和Object.fromEntries简化对象的遍历与重组，用数组map/forEach简化数组处理，比原始的for循环更简洁。

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