Question

我有一组嵌套对象。这些对象采用以下两种形式之一：

// type a
{
    value: 'some value'
}

或

// type b
{
    array: [
        object of type a or b,
        object of type a or b,
        ...
    ]
}

因此，基本数组可以无限嵌套。给定一系列索引（我一直称它为“树”），如何在任何深度删除单个项目？

我目前的样本：

const baseArray = [
    { value: 'some value' },
    { array: [
            { value: 'some value' },
            { array: [
                    { value: 'some value' },
                    { value: 'some value' },
                ],
            },
            { value: 'some value' },
            { array: [
                    { value: 'some value' },
                    { array: [
                            { value: 'delete me' },
                            { value: 'some value' },
                        ]
                    },
                ],
            },
        ],
    }
]

const tree = [1, 3, 1, 0]

function deleteNested(tree, inputArray) {
    const index = tree.shift();
    console.log(inputArray, index);
    const child = inputArray[index].array;
    if (tree.length > 0) {
        console.log(child)
        return deleteNested(tree, child);
    }
    return [
        ...inputArray.slice(0, index),
        ...inputArray.slice(index + 1)
    ]
}
const originalArray = baseArray.slice(0);
console.log(deleteNested(tree, baseArray), originalArray);

我想删除标记的对象，因为它是'树'位置：[1, 3, 1, 0]：

首先，查看初始数组的1（索引1，而不是0）值，
然后是3值，
然后查看1值，
然后最终删除0值。

我上面所做的不起作用，但让我开始了。

该函数需要递归才能在任何深度工作。理想情况下，不应该使用splice()来避免修改传递给它的数组 - 相反，它应该返回一个新数组。

Answer 1

正如我在评论中所说，如果您事先了解迭代次数，则不应使用递归方法。 while循环是理想的，例如;

function delNestedItem(a,dm){
  var i = 0;
  while (i < dm.length-1) a = a[dm[i++]].array;
  a.splice(dm[i],1);
}

var data = [
    { value: 'some value' },
    { array: [
            { value: 'some value' },
            { array: [
                    { value: 'some value' },
                    { value: 'some value' },
                ],
            },
            { value: 'some value' },
            { array: [
                    { value: 'some value' },
                    { array: [
                            { value: 'delete me' },
                            { value: 'some value' },
                        ]
                    },
                ],
            },
        ],
    }
          ],

delMark = [1, 3, 1, 0];
delNestedItem(data,delMark);
console.log(JSON.stringify(data,null,2));

Answer 2

以下是如何在1减少：

＆＃13;

const baseArray = [{
  value: 'some value'
}, {
  array: [{
    value: 'some value'
  }, {
    array: [{
      value: 'some value'
    }, {
      value: 'some value'
    }, ],
  }, {
    value: 'some value'
  }, {
    array: [{
      value: 'some value'
    }, {
      array: [{
        value: 'delete me'
      }, {
        value: 'some value'
      }, ]
    }, ],
  }, ],
}];

const tree = [1, 3, 1, 0];


var deleted = tree.reduce(function(pos, pathIndex, index, arr) {
  if (index + 1 < arr.length) {
    return pos.array
      ? pos.array[pathIndex]
      : pos[pathIndex];
  } else {
    pos.array = pos.array
            .slice(0, pathIndex)
            .concat(pos.array.slice(pathIndex + 1));
    return pos;
  }

}, baseArray);
            
            console.log(baseArray);

＆＃13;

Answer 3

只能使用未删除的部分从给定数组中生成一个新数组。

function ff(array, tree) {
    function iter(array, level) {
        var r = [];
        array.forEach(function (a, i) {
            if (tree[level] !== i) {
                return r.push(a);
            }
            if (level + 1 !== tree.length && a.array) {
                r.push({ array: iter(a.array, level + 1) });
            }
        });
        return r;
    }
    return iter(array, 0);
}

var baseArray = [{ value: 'some value' }, { array: [{ value: 'some value' }, { array: [{ value: 'some value' }, { value: 'some value' }, ], }, { value: 'some value' }, { array: [{ value: 'some value' }, { array: [{ value: 'delete me' }, { value: 'some value' }, ] }, ], }, ], }],
    tree = [1, 3, 1, 0],
    copy = ff(baseArray, tree);

console.log(copy);
console.log(baseArray);

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

通过索引（递归）从嵌套数组中删除项

3 个答案: