Question

我有嵌套的树对象，我希望在不丢失结构的情况下进行过滤

var items = [
    {
        name: "a1",
        id: 1,
        children: [{
            name: "a2",
            id: 2,
            children: [{
                name: "a3",
                id: 3
            }]
        }]
    }
];

所以例如，如果id == 2删除id为2的对象和他的孩子

如果id == 3，则只删除id为3的对象

这只是对象的一个问题，但是它自己包含的对象越来越多：）

使用vanilla javascript，_lodash或Angular2，没关系

谢谢

Answer 1

您可以使用filter()创建递归函数，如果value为Array，也可以继续过滤子项。

var items = [{
  name: "a1",
  id: 1,
  children: [{
    name: "a2",
    id: 2,
    children: [{
      name: "a3",
      id: 3
    }, ]
  }]
}];

function filterData(data, id) {
  var r = data.filter(function(o) {
    Object.keys(o).forEach(function(e) {
      if (Array.isArray(o[e])) o[e] = filterData(o[e], id);
    })
    return o.id != id
  })
  return r;
}

console.log(filterData(items, 3))
console.log(filterData(items, 2))

更新：正如Nina所说，如果您知道子类是带数组的属性，则不需要循环键，您可以直接定位children属性。

var items = [{
  name: "a1",
  id: 1,
  children: [{
    name: "a2",
    id: 2,
    children: [{
      name: "a3",
      id: 3
    }, ]
  }]
}];

function filterData(data, id) {
  var r = data.filter(function(o) {
    if (o.children) o.children = filterData(o.children, id);
    return o.id != id
  })
  return r;
}

console.log(JSON.stringify(filterData(items, 3), 0, 4))
console.log(JSON.stringify(filterData(items, 2), 0, 4))

Answer 2

您可以使用Array#some的迭代方法，并为子项调用回调iter。我找到了，拼接。

function deleteItem(id) {
    items.some(function iter(a, i, aa) {
        if (a.id === id) {
            aa.splice(i, 1);
            return true;
        }
        return a.children.some(iter);
    });
}

var items = [{ name: "a1", id: 1, children: [{ name: "a2", id: 2, children: [{ name: "a3", id: 3 }] }] }];

console.log(items);
deleteItem(3);
console.log(items);
deleteItem(2);
console.log(items);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

使用递归函数：

＆＃13;

var items = [
    {
        name: "a1",
        id: 1,
        children: [{
            name: "a2",
            id: 2,
            children: [{
                name: "a3",
                id: 3,
                children: [{
                    name: "a4",
                    id: 4,
                }]
            }]
        }]
    }
];

function filterId(items, id) {
  var len = items.length;
  while (len--) {
    if (items[len].id === id) {
      items.splice(len, 1);
      break;
    } else {
      filterId(items[len].children, id);
    }
  }
  return items;
}

// filtering out the item with 'id' = 4
console.log(filterId(items, 4));

// filtering out the item with 'id' = 2
console.log(filterId(items, 2));

＆＃13;

Answer 4

如果可以使用Lodash + Deepdash，则：

let filtered = _.filterDeep(items,(i)=>i.id!=3,{tree:true});

这里是demo Codepen

过滤嵌套的树对象而不会丢失结构

4 个答案: