Javascript 如何使用lodash更新对象的嵌套数组

我有一个嵌套的对象数组，如下面的结构。我想循环到每个对象中，检查特定字段是否与条件匹配。如果匹配，则更新该特定对象

结构

{
  "condition": "and",
  "rules": [
    {
      "condition": "and",
      "rules": [
        {
          "field": "deviceName",
          "operator": "=",
          "value": "device01"
        },
        {
          "field": "temperature",
          "operator": ">",
          "value": 30
        },
        {
          "field": "mail",
          "operator": "to",
          "value": "edison@gmail.com"
        }
      ]
    },
    {
      "condition": "and",
      "rules": [
        {
          "field": "deviceName",
          "operator": "=",
          "value": "device02"
        },
        {
          "field": "voltage",
          "operator": "=",
          "value": 200
        },
        {
          "field": "log",
          "operator": "to",
          "value": "edison@gmail.com"
        },
        {
          "condition": "and",
          "rules": [
            {
              "field": "deviceName",
              "operator": "=",
              "value": "device04"
            },
            {
              "field": "voltage",
              "operator": "=",
              "value": 200
            },
            {
              "field": "mail",
              "operator": "to",
              "value": "edison@gmail.com"
            }
          ]
        }
      ]
    }
  ]
}

在上面的结构中，我检查每个规则[]，并检查字段是否具有值email或log。如果匹配，则我将类型设置为action else条件

我已经尝试了map，但它只在第一级起作用。假设对象具有嵌套数组，我无法对其进行筛选

  const queryDetail = this.query.rules.map((query: any) => {
    const temp: any = {
      condition: {
        ...query
      }
    };
    if (query.field === 'mail' || query.field === 'log') {
      temp.type = 'action';
    } else {
      temp.type = 'condition';
    }
    return temp;
  });

  const updatedQuery = {
    condition: this.query.condition,
    rules: queryDetail
  };

---

你不需要用Lodash来做这个。您可以采用递归方法

首先，规则分为“简单”和“复杂”

• 简单规则有

  字段

  、

  运算符

  和

  值

  字段
• 复杂规则具有

  规则

  属性

考虑到这一点，对每个规则应用以下逻辑：

将规则转换为克隆它

如果这是一个复杂的规则，那么：

• 检查其子规则。如果任何直接子项的值为

  'email'

  或

  'log'

  ，则将当前复杂规则的

  类型设置为
  'action'
  。否则将其设置为
  “条件”
  。即使子规则很复杂，这也会起作用，因为它们没有
  字段
  属性，因此将被视为与筛选器不匹配的简单规则

• 对所有子规则应用相同的逻辑

const data={“条件”：“和”，“规则”：[{“条件”：“和”，“规则”：[{“字段”：“设备名称”，“运算符”：“=”，“值”：“设备01”}，{“字段”：“温度”，“运算符”：“>”，“值”：30}，{“字段”：“邮件”，“运算符”：“到”，“值”：”edison@gmail.com“}]}，{”条件“：”和“，”规则“[{”字段“：”设备名称“，”运算符“：=”，“值”：“设备02”}，{“字段”：“电压”，“运算符”：“=”，“值”：200}，{“字段”：“日志”，“运算符”：“至”，“值”：”edison@gmail.com“}，{”条件“：”和“，”规则“[{”字段“：”设备名称“=”，“运算符“：”设备04“}，{”字段“：”电压“，”运算符“：”，”值“：”200}，{”字段“：”邮件“，”运算符“：”收件人“，”值“："edison@gmail.com" } ] } ] } ] }
函数转换规则（obj）{
//克隆规则
const result={…obj}；
obj中的const isComplexRule=“rules”；
if（isComplexRule）{
//检查子规则
const isActionRule=obj.rules.some（checkSimpleRule）；
//设置适当的操作
if（isActionRule）{
result.type='action'；
}否则{
result.type='条件'；
}
//在每个子规则上递归地重新运行相同的逻辑
result.rules=result.rules.map（convertRule）
}
//返回克隆的对象
返回结果；
}
函数检查单体（规则）{
return rule.field=='mail'| | rule.field=='log'
}
const queryDetail=convertRule（数据）
console.log（queryDetail）

您的数据无效，它正在抱怨缺少

]

@VLAZ我已经更新了数据