您也可以使用JSON.parse和reviver function来执行此操作：

JSON.parse(JSON.stringify(obj), (key, value ) => key === 'ative' ? false : value );

const obj = {
    name: 'obj1',
    ative: true,
    children: [{
        name: 'obj2',
        ative: true,
        children: [{
            name: 'Obj23',
            ative: true,
            children: []
        }]
    },
    {
        name: 'obj3',
        children: [{
            name: 'Obj32',
            ative: true,
            children: []
        }]
    }]
}

const result = JSON.parse(JSON.stringify(obj), (key, value) => key === 'ative' ? false : value);

console.log(result);

可以使用两种主要方法
1.迭代法
1.递归方法
在大多数情况下，迭代方法在内存和速度上都更好，因为递归方法需要O(n)额外内存来用于调用堆栈中的每个调用。
在迭代方法中，map和forEach数组方法将是无用的，因为我们不知道长度和何时停止，即使设法使用它们，也需要我们改变遍历的数组，这会导致副作用。相反，我们将使用一个简单的while循环。
算法：

• 创建一个堆栈数组并将输入对象放入其中
• While堆栈不为空
• 让当前元素为堆栈中弹出的元素
• 将当前的active设置为false
• 将当前的子级添加到堆栈中以遍历其子级
• 返回项（可选的，因为我们改变了输入对象）

实施：
首先，让我们为输入数据结构创建一个类型：

type Item = {
  name: string;
  active?: boolean;
  children: Item[];
};

现在，函数本身：

const setActive = (data: Item): Item => {
  const stack = [data];

  while (stack.length) {
    const current = stack.pop();

    if (!current) continue;

    current.active = false;

    stack.push(...current.children);
  }

  return data;
};

playground

我并不反对wonderflame的观点，如果你不知道你的树会增长到多大，基于堆栈的方法更好，但是如果你知道你只会深入几层，那么优化可能就不需要了，递归方法更简单。

function deactiveRecursive(obj) {

  return {
    ...obj,
    active: false,
    children: obj.children.map(child => deactivateRecursive(child));
  };
}