Javascript 基于多个条件从复杂数组结构中删除数据

我正在接收以下格式的json数据

[
   {
      "key":4,
      "data":{
         "choice":[
            {
               "id":"1.1"
            },
            {
               "id":"1.2"
            }
         ],
         "questionId":"1"
      }
   },
   {
      "key":4,
      "data":{
         "choice":[
            {
               
               "id":"1.1.1.1"
            },
            {
               "id":"1.1.1.2"
            },
            {
               "id":"1.1.1.3",
            }
         ],
         "questionId":"1.1"
      }
   },
   {
      "key":4,
      "data":{
         "choice":[
            {

               "id":"1.1.1.3.1.1" 
            },
            {
               "id":"1.1.1.3.1.2"
            }
         ],
         "questionId":"1.1.1.3"
      }
   },
   {
      "key":4,
      "data":{
         "choice":[
            {
               "id":"1.1.1.3.1.1.1.1"
            },
            {
               "id":"1.1.1.3.1.1.1.2"
            }
         ],
         "questionId":"1.1.1.3.1.1"
      }
   },
   {
      "key":5,
      "data":{
         "choice":[
            {
               "id":"2.1"
            },
            { 
               "id":"2.2"
            }
         ],
         "questionId":"2"
      }
   },
   {
      "key":5,
      "data":{
         "choice":[
            
         ],
         "questionId":"2.2"
      },
      }
]

我想根据以下多个条件从这个数组中删除记录

“密钥”，假设我将密钥传递为4，则只应考虑删除密钥为4的记录，不应删除密钥为5的任何记录

第二个是id假设我得到的id（这是内部选择）是“1.1.1.2”，那么只有之后的记录应该被删除

因此，对于eg，我得到的键是4，id是“1.1.1.2”，那么预期的输出应该如下

[

我尝试在forEach内部使用splice，但似乎在forEach内部使用splice时，会出现一种不寻常的行为

我正在尝试的代码

  this.followUpQues.forEach(function(val,index,object) { 
    if(val.data.choice.filter(y=>y.id === item.id).length >= 1) {
          keyNumber = val.key;
          valueIndex = index;
    }
 }) 

因此，在获得键和索引后，我尝试在找到索引并具有标识的键值后删除记录，但在foreach中使用splice有奇怪的行为

let json=[
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1”
},
{
“id”：“1.2”
}
],
“问题ID”：“1”
}
},
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1.1.1”
},
{
“id”：“1.1.1.2”
},
{
“id”：“1.1.1.3”，
}
],
“问题ID”：“1.1”
}
},
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1.1.3.1.1”
},
{
“id”：“1.1.1.3.1.2”
}
],
“问题ID”：“1.1.1.3”
}
},
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1.1.3.1.1.1.1”
},
{
“id”：“1.1.1.3.1.1.1.2”
}
],
“问题ID”：“1.1.1.3.1.1”
}
},
{
“关键”：5，
“数据”：{
“选择”：[
{
“id”：“2.1”
},
{ 
“id”：“2.2”
}
],
“问题ID”：“2”
}
},
{
“关键”：5，
“数据”：{
“选择”：[
],
“问题ID”：“2.2”
},
}
];
让我们检查=（json，key，id）=>json.map（（it，i）=>it.key！==key | i==0？it:json[i-1]。data.choice.map（（k，v）=>k.id）。包括（id）？null:it）。过滤器（it=>it！==null）；
log（inspect（json，4，'1.1.1.2'））；

更新 如果您的意思是删除出现

“1.1.1.2”

后的所有内容，则

let inspect=（json，key，id）=>{
let processed=json.map（（it，i）=>it.key！==key | | i==0？it:json[i-1]。data.choice.map（（k，v）=>k.id）。包含（id）？null:it）；
返回已处理。筛选器（（it，i）=>
it==null？false:it.key！==key | | i

您可以使用简单的

for

循环：

choiceFound = 0
for(let i = 0; i < questions.length; i++ ){
    let question = questions[i];
    if(question.key == 4){
        if(!choiceFound) {
            choiceFound = question.data.choice.find(c => c.id == "1.1.1.2") ? 1: 0;
        }
        else {
            questions.splice(i, 1); 
            i--;
        }
    }
}

choiceFound=0
for（设i=0；ic.id==“1.1.1.2”）？1:0；
}
否则{
问题.拼接（i，1）；
我--；
}
}
}

此问题可分为两个步骤。首先查找与所需谓词匹配的第一个索引，然后在给定键上筛选索引后的结果集。如果您希望效率最高，可以组合这些步骤，但代码可读性将受到影响

const data = [
   {
      "key":4,
      "data":{
         "choice":[
            {
               "id":"1.1"
            },
            {
               "id":"1.2"
            }
         ],
         "questionId":"1"
      }
   },
   {
      "key":4,
      "data":{
         "choice":[
            {
               
               "id":"1.1.1.1"
            },
            {
               "id":"1.1.1.2"
            },
            {
               "id":"1.1.1.3",
            }
         ],
         "questionId":"1.1"
      }
   },
   {
      "key":4,
      "data":{
         "choice":[
            {

               "id":"1.1.1.3.1.1" 
            },
            {
               "id":"1.1.1.3.1.2"
            }
         ],
         "questionId":"1.1.1.3"
      }
   },
   {
      "key":4,
      "data":{
         "choice":[
            {
               "id":"1.1.1.3.1.1.1.1"
            },
            {
               "id":"1.1.1.3.1.1.1.2"
            }
         ],
         "questionId":"1.1.1.3.1.1"
      }
   },
   {
      "key":5,
      "data":{
         "choice":[
            {
               "id":"2.1"
            },
            { 
               "id":"2.2"
            }
         ],
         "questionId":"2"
      }
   },
   {
      "key":5,
      "data":{
         "choice":[
            
         ],
         "questionId":"2.2"
      },
      }
];

const remove = (data, key, id) => {
  let result = data;
 
  // find first index that matches our predicate.
  // first the key has to match, and then the id must be contained within our choices.
  const index = data.findIndex((n) => {
    return n.key === key && n.data.choice.findIndex((m) => m.id === id) !== -1;
  });
 
  // did we find something? If so start filtering!
  if (index !== -1) {
    result = data.filter((n, i) => {
      // is this element before our filter index? or maybe its not the right key?
      // if either are true, keep the element.
      return i <= index || n.key !== key;
    });
 }
 
 return result;
};

console.log(remove(data, 4, "1.1.1.2"));

const数据=[
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1”
},
{
“id”：“1.2”
}
],
“问题ID”：“1”
}
},
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1.1.1”
},
{
“id”：“1.1.1.2”
},
{
“id”：“1.1.1.3”，
}
],
“问题ID”：“1.1”
}
},
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1.1.3.1.1”
},
{
“id”：“1.1.1.3.1.2”
}
],
“问题ID”：“1.1.1.3”
}
},
{
"关键":四,，
“数据”：{
“选择”：[
{
“id”：“1.1.1.3.1.1.1.1”
},
{
“id”：“1.1.1.3.1.1.1.2”
}
],
“问题ID”：“1.1.1.3.1.1”
}
},
{
“关键”：5，
“数据”：{
“选择”：[
{
“id”：“2.1”
},
{ 
“id”：“2.2”
}
],
“问题ID”：“2”
}
},
{
“关键”：5，
“数据”：{
“选择”：[
],
“问题ID”：“2.2”
},
}
];
常量删除=（数据、键、id）=>{
让结果=数据；
//查找与谓词匹配的第一个索引。
//首先，密钥必须匹配，然后id必须包含在我们的选择中。
常量索引=数据。findIndex（（n）=>{
返回n.key==key和n.data.choice.findIndex（（m）=>m.id==id）！=-1；
});
//我们找到什么了吗？如果找到了，开始过滤吧！
如果（索引！=-1）{
结果=数据。过滤器（（n，i）=>{
//这个元素在我们的筛选索引之前吗？或者它不是正确的键？
//如果其中一个为true，则保留该元素。
返回i避免嵌套if条件

    choiceFound = 0
    for(let i = 0; i < questions.length; i++ ){
        let question = questions[i];
        if(question.key == 4 && !choiceFound){
           choiceFound = question.data.choice.find(c => c.id == "1.1.1.2") ? 1: 0;
         }
         else {
                questions.splice(i, 1); 
                i--;
            }
        }

choiceFound=0
for（设i=0；ic.id==“1.1.1.2”）？1:0；
}
否则{
    choiceFound = 0
    for(let i = 0; i < questions.length; i++ ){
        let question = questions[i];
        if(question.key == 4 && !choiceFound){
           choiceFound = question.data.choice.find(c => c.id == "1.1.1.2") ? 1: 0;
         }
         else {
                questions.splice(i, 1); 
                i--;
            }
        }