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

Nidhin kumar

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

结构体

{
  "condition": "and",
  "rules": [
    {
      "condition": "and",
      "rules": [
        {
          "field": "deviceName",
          "operator": "=",
          "value": "device01"
        },
        {
          "field": "temperature",
          "operator": ">",
          "value": 30
        },
        {
          "field": "mail",
          "operator": "to",
          "value": "[email protected]"
        }
      ]
    },
    {
      "condition": "and",
      "rules": [
        {
          "field": "deviceName",
          "operator": "=",
          "value": "device02"
        },
        {
          "field": "voltage",
          "operator": "=",
          "value": 200
        },
        {
          "field": "log",
          "operator": "to",
          "value": "[email protected]"
        },
        {
          "condition": "and",
          "rules": [
            {
              "field": "deviceName",
              "operator": "=",
              "value": "device04"
            },
            {
              "field": "voltage",
              "operator": "=",
              "value": 200
            },
            {
              "field": "mail",
              "operator": "to",
              "value": "[email protected]"
            }
          ]
        }
      ]
    }
  ]
}

在上面的结构中，我正在检查每个rules []，并检查该字段是否具有值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
  };

VLAZ

您不需要Lodash。您可以采用递归方法。

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

简单的规则有field，operator和value领域。
复杂的规则具有rules属性。

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

转换克隆它的规则。
如果这是一个复杂的规则，则：
- 检查其子规则。如果任何直属子代的字段值为'email'或'log'，则将type当前复杂规则的设置为'action'。否则将其设置为'condition'。即使子规则很复杂，这也将起作用，因为它们不具有该field属性，因此将其视为与过滤器不匹配的简单规则一样。
- 对所有子规则应用相同的逻辑。

const data = { "condition": "and", "rules": [{ "condition": "and", "rules": [{ "field": "deviceName", "operator": "=", "value": "device01" }, { "field": "temperature", "operator": ">", "value": 30 }, { "field": "mail", "operator": "to", "value": "[email protected]" } ] }, { "condition": "and", "rules": [{ "field": "deviceName", "operator": "=", "value": "device02" }, { "field": "voltage", "operator": "=", "value": 200 }, { "field": "log", "operator": "to", "value": "[email protected]" }, { "condition": "and", "rules": [{ "field": "deviceName", "operator": "=", "value": "device04" }, { "field": "voltage", "operator": "=", "value": 200 }, { "field": "mail", "operator": "to", "value": "[email protected]" } ] } ] } ] }


function convertRule(obj) {
  //clone the rule
  const result = {...obj};
  const isComplexRule = "rules" in obj;

  if (isComplexRule) {
    //check sub-rules
    const isActionRule = obj.rules.some(checkSimpleRule);
    
    //set the appropriate action
    if (isActionRule) {
      result.type = 'action';
    } else {
      result.type = 'condition';
    }
    
    //re-run the same logic on each sub-rule recursively
    result.rules = result.rules.map(convertRule)
  }

  //return the cloned object
  return result;
}

function checkSimpleRule(rule) {
  return rule.field === 'mail' || rule.field === 'log'
}
const queryDetail = convertRule(data)

console.log(queryDetail)

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。