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

Question

As an example - I've included a one element array that contains an object that has a Children key, which is an array of objects and each object also has its' own Children key that contains another array.

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

There is a second array of objects that I would like to compare the first array of objects to, with the intention of making sure that the first array is in the same order as the second array of objects, and if it is not - then sort until it is.

Here is the second array:

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

The data that this will run on can be up in the tens of thousands - so performance is paramount.

What I'm currently attempting is using a utility method to convert each element of the second array into a keyed object of objects eg

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

This allows fast look up from the top level. I'm wondering if I should continue doing this all the way down or if there is an idiomatic way to accomplish this. I considered recursion as well. The order of the already sorted array is not based on Id - it is arbitrary. So the order needs to be preserved regardless.

Answer 1

Assuming same depth and all Id's exist in each level of each object use a recursive function that matches using Array#findIndex() in sort callback

 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>