在对象数组中，根据某个属性，删除树形结构中的某一项数据

目的

把下面这个数据 （根据code判断，当 code 为 false 时，去除该项）

let arr = [
  {
    name: "a",
    age: 1,
    code: true,
    children: [
      {
        name: "b",
        age: 2,
        code: true,
        children: [
          {
            name: "c",
            age: 1,
            code: false,
          },
          {
            name: "d",
            age: 5,
            code: true,
          },
        ],
      },
    ],
  },
  {
    name: "akkaa",
    age: 9,
    code: false
  },
  {
    name: "ag",
    age: 1,
    code: true,
    children: [
      {
        name: "b",
        age: 2,
        code: true
      },
      {
          name: 'bbg',
          age: 8,
          code: false
      }
    ],
  },
  {
    name: "akk",
    age: 7
  }
];

转换成

let arr = [
  {
    name: "a",
    age: 1,
    code: true,
    children: [
      {
        name: "b",
        age: 2,
        code: true,
        children: [
          {
            name: "d",
            age: 5,
            code: true,
          }
        ]
      }
    ]
  },
  {
    name: "ag",
    age: 1,
    code: true,
    children: [
      {
        name: "b",
        age: 2,
        code: true
      }
    ]
  },
  {
    name: "akk",
    age: 7
  },
];

实现- 两个方法

1. 使用 额外空间，数组本身数据不改变

let clone = []
const deep = (list, data) => {
     list.forEach((item) => {
        if (item.code == undefined) {
            data.push(item)
        }else if (item.code) {
            //深拷贝数据，JSON.parse(JSON.stringify(item))可能会出问题
            let v = JSON.parse(JSON.stringify(item))
            if (v.children) {
                delete v.children
                v.children = []
            }
            data.push(v)
            if (item.children) {
                deep(item.children, data[data.length - 1].children)
            }
        }
    })
}
deep(arr, clone)
console.log(clone)

2. 改变数组本身数据

const deep = (list) => {
  //需要使用 for 循环， forEach不支持
  for (let i = 0; i < list.length; i++) {
    if (list[i].code == undefined) {
    } else if (list[i].code) {
      if (list[i].children && list[i].children.length) {
        deep(list[i].children);
      }
    } else {
      list.splice(i, 1)
      // i需要自减，否则每次删除都会讲原数组索引发生变化
      i--;
    }
  }
};

运行结果