Question

作为示例-我包含一个元素 array ，其中包含一个 object ，该对象具有 Children 键，该键是一个< strong>对象数组，每个对象也都有自己的 Children 键，其中包含另一个数组。

[
  {
    "Id": "1",
    "Children": [
      {
        "Id": "2",
        "Children": [
          {
            "Id": "10",
            "DisplayName": "3-4",
          },
          {
            "Id": "1000",
            "DisplayName": "5-6",
          },
          {
            "Id": "100",
            "DisplayName": "1-2",
          },
        ]
      }
    ]
  }
]

有一个第二个对象数组，我想比较第一个对象数组，目的是确保则第一个数组与对象的第二个数组的顺序相同，如果不是，则排序直到它。

这是第二个数组：

[
  {
    "Id": "1",
    "Children": [
      {
        "Id": "2",
        "Children": [
           {
            "Id": "100",
            "DisplayName": "1-2",
          },
          {
            "Id": "10",
            "DisplayName": "3-4",
          },
          {
            "Id": "1000",
            "DisplayName": "5-6",
          },
        ]
      }
    ]
  }
]

将要运行的数据可能高达数万个-因此性能至关重要。

我目前正在尝试使用实用程序方法将第二个数组的每个元素转换为对象的键控对象，例如

{
   1:  {
        "Id": "1",
        "Children": [
          {
            "Id": "2",
            "Children": [
              {
                "Id": "4",
                "DisplayName": "3-4",
              },
              {
                "Id": "3",
                "DisplayName": "1-2",
              },
            ]
          }
        ]
      }
}

这允许从顶层快速查找。我想知道我是否应该一直继续这样做，或者是否有惯用的方式来完成此任务。我也考虑了递归。已经排序的数组的顺序不是基于ID的-它是任意的。因此，无论如何都需要保留订单。

Answer 1

假设每个对象的每个级别中的深度相同且所有ID存在，请使用递归函数，该函数在排序回调中使用Array#findIndex()进行匹配

function sortChildren(main, other) {
  other.forEach((o, i) => {
    if (o.children) {
      const mChilds = main[i].children, oChilds = o.children;
      
      oChilds.sort((a, b) => {
        return mChilds.findIndex(main => main.Id === a.Id) - mChilds.findIndex(main => main.Id === b.Id)
      });
      // call function again on this level passing appropriate children arrays in
      sortChildren(mChilds, oChilds)
    }
  })
}

sortChildren(data, newData);
console.log(JSON.stringify(newData, null, ' '))

<script>
  var data = [{
    "Id": "1",
    "Children": [{
      "Id": "2",
      "Children": [{
          "Id": "3",
          "DisplayName": "1-2",
        },
        {
          "Id": "4",
          "DisplayName": "3-4",
        },
      ]
    }]
  }]

  var newData = [{
    "Id": "1",
    "Children": [{
      "Id": "2",
      "Children": [{
          "Id": "4",
          "DisplayName": "3-4",
        },
        {
          "Id": "3",
          "DisplayName": "1-2",
        },
      ]
    }]
  }]

</script>

通过另一种深度嵌套的对象数组对一种深度嵌套的对象数组进行排序的最有效方法

1 个答案: