Javascript 从数组中删除对象，对象的值与正则表达式模式匹配

下面给出了一个javascript数组，我试图删除与父元素的级别模式匹配的对象。例如，如果类型为父级，级别为1-2，则我希望删除具有级别1-2-1、1-2-2、1-2-3的子级

var arr = [{
    type: "parent",
    Level: "1-1",
  },
  {
    type: "parent",
    Level: "1-2",
  },
  {
    type: "child",
    Level: "1-2-1",
  },
  {
    type: "child",
    Level: "1-2-2",
  },
  {
    type: "child",
    Level: "1-2-3",
  } {
    type: "parent",
    Level: "1-3",
  }
];

我正试图用正则表达式完成它，但现在还不能真正做到。有人能帮我吗？或者是否有任何可以使用的lodash方法

更新

这是我到目前为止尝试过的，我知道它没有使用正则表达式，但可能它可以实现我所期望的

var parentLevel = "1-2" + "-";
var length = arr.length;
for (var k = 0; k < length; k++) {
  if (arr[k].Level.startsWith(parentLevel)) {
    arr.splice(k, 1);
  }
}

var parentLevel=“1-2”+“-”；
变量长度=arr.length；
对于（var k=0；k

注意：请记住，这只会删除直接子级。如果要删除所有子项，请使用

newregexp（“^”+parent+”[\-0-9]+$”

实现此目的

var-arr=[{
键入：“父项”，
级别：“1-1”，
},{
键入：“父项”，
级别：“1-2”，
},{
键入：“child”，
级别：“1-2-1”，
},{
键入：“child”，
级别：“1-2-2”，
},{
键入：“child”，
级别：“1-2-3”，
},{
键入：“child”，
级别：“1-4-3”，
},{
键入：“父项”，
级别：“1-3”，
}
];
var nodetoberemoved=“1-2”；
var结果=arr.filter（函数（elem）{
return！elem.Level.indexOf（nodetoberemoved+“-”==0；
});
console.log（result）

我认为这是一个满足您需求的动态解决方案

var arr = [{
    type: "parent",
    Level: "1-1",
  },{
    type: "parent",
    Level: "1-2",
  },{
    type: "child",
    Level: "1-2-1",
  },{
    type: "child",
    Level: "1-2-2",
  },{
    type: "child",
    Level: "1-2-3",
  },{
    type: "child",
    Level: "1-4-3",
  },{
    type: "parent",
    Level: "1-3",
  }
];

//Separate the parents and children into two arrays so we can loop through them.
var parents = arr.filter(elem => elem.type === 'parent')    
var children = arr.filter(elem => elem.type === 'child')

//Loop over arrays to remove children from the variable arr
parents.forEach(parent => {
    // Dynamically build a regex to filter out the children
    var regEx = new RegExp("^" + parent.Level + "-");

    children.forEach(child => {
        //if child matches a parent level it will be removed from the original arr variable
        if(regEx.test(child.Level)){
            arr.splice(arr.indexOf(child, 0),1)
        }
    })
})

---

你能给我们看一个你试过的例子吗？我会用另一种结构，比如树，然后用lvl删除树。你能证明你已经试过的代码吗？期望返回的内容。您想要一个对象数组，该数组包含所有的父对象，并且只有没有父对象的子对象？基本上，当与模式匹配的子对象被删除后，数组会是什么样子。

arr.filter（obj=>obj.type！='child'| | |！obj.Level.match（/^1-2\b/）

@Lewis我已经更新了问题，请看一看我无法真正检查对象是父对象还是子对象，因为它将是一个多层次的层次结构。你的意思是，如果有一个孩子的

级别为1-4-3

，另一个孩子的

级别为1-4-3-5

，那么前者是后者的父级。然后，您应该删除第二个？或者如果您还想删除父级。例如，如果我有一个

级别1-2

，那么我应该删除

级别1-2-*

的对象，无论其类型是

父级

还是

子级

？我已经将此数据绑定到树视图中的视图，因此，如果我单击一个树节点，我想删除该父节点的所有子节点。您想只删除子节点还是包括您单击的节点？我已修改了问题，同时我将尝试您的建议。谢谢

var arr = [{
    type: "parent",
    Level: "1-1",
  },{
    type: "parent",
    Level: "1-2",
  },{
    type: "child",
    Level: "1-2-1",
  },{
    type: "child",
    Level: "1-2-2",
  },{
    type: "child",
    Level: "1-2-3",
  },{
    type: "child",
    Level: "1-4-3",
  },{
    type: "parent",
    Level: "1-3",
  }
];

//Separate the parents and children into two arrays so we can loop through them.
var parents = arr.filter(elem => elem.type === 'parent')    
var children = arr.filter(elem => elem.type === 'child')

//Loop over arrays to remove children from the variable arr
parents.forEach(parent => {
    // Dynamically build a regex to filter out the children
    var regEx = new RegExp("^" + parent.Level + "-");

    children.forEach(child => {
        //if child matches a parent level it will be removed from the original arr variable
        if(regEx.test(child.Level)){
            arr.splice(arr.indexOf(child, 0),1)
        }
    })
})