Question

我想遍历一个深层嵌套的对象，并根据属性对每个级别进行排序。在这种情况下，其id

在这里放置我的对象（我会得到更多的等级，这里我添加了3个等级以提高可读性）：

const myObj = [
  {
    id: 15,
    children: [
      {
        id: 9,
        children: [
          {
            id: 4,
            children: []
          },
          {
            id: 1,
            children: []
          }
        ]
      },
      {
        id: 4,
        children: [
          {
            id: 35,
            children: [
              {
                id: 12,
                children: []
              },
              {
                id: 8,
                children: []
              }
            ]
          },
          {
            id: 30,
            children: [],
          }
        ]
      },
    ]
  },
  {
    id: 2,
    children: [
      {
        id: 9,
        children: []
      },
      {
        id: 3,
        children: []
      },
    ]
  }
]

这是所需的输出：

const myObj = [
  {
    id: 2,
    children: [
      {
        id: 3,
        children: []
      },
      {
        id: 9,
        children: []
      }
    ]
  },
  {
    id: 15,
    children: [
      {
        id: 4,
        children: [
          {
            id: 30,
            children: [],
          },
          {
            id: 35,
            children: [
              {
                id: 8,
                children: []
              },
              {
                id: 12,
                children: []
              }
            ]
          },
        ]
      },
      {
        id: 9,
        children: [
          {
            id: 1,
            children: []
          },
          {
            id: 4,
            children: []
          }
        ]
      },
    ]
  }
]

这是我对它进行排序的尝试：

const myObj = [{id:15,children:[{id:9,children:[{id:4,children:[]},{id:1,children:[]}]},{id:4,children:[{id:35,children:[{id:12,children:[]},{id:8,children:[]}]},{id:30,children:[],}]},]},{id:2,children:[{id:9,children:[]},{id:3,children:[]},]}]

function sortByOrderIndex(obj) {
  obj.sort((a, b) => (a.orderindex > b.orderindex) ? 1 : ((b.orderindex > a.orderindex) ? -1 : 0));

  return obj;
}

function sortNestedObj(obj) {
  sortByOrderIndex(obj);

  for (let i = 0; i < obj.length; i++) {
    const t = obj[i];

    if (t.children.length !== 0) {
      sortNestedObj(t.children);
    } else {
      return;
    }
  }
}

console.log(sortByOrderIndex(myObj))

我创建了一个对对象进行排序的函数，然后尝试创建另一个对象，该对象遍历每个具有子对象的对象，并使用第一个函数对这些子对象进行排序。如果这些孩子有孩子，则对这些孩子进行排序，直到一个孩子没有孩子。

任何帮助将不胜感激。谢谢！

Answer 1

您可以像这样递归地sort数组及其对象的children：

const myObj = [{id:15,children:[{id:9,children:[{id:4,children:[]},{id:1,children:[]}]},{id:4,children:[{id:35,children:[{id:12,children:[]},{id:8,children:[]}]},{id:30,children:[],}]},]},{id:2,children:[{id:9,children:[]},{id:3,children:[]},]}]

function sortArray(array) {
  array.sort((a, b) => a.id - b.id);
  array.forEach(a => {
    if (a.children && a.children.length > 0)
      sortArray(a.children)
  })
  return array;
}

console.log(sortArray(myObj))

Answer 2

您可以创建递归排序功能：

const myObj = [{id:15,children:[{id:9,children:[{id:4,children:[]},{id:1,children:[]}]},{id:4,children:[{id:35,children:[{id:12,children:[]},{id:8,children:[]}]},{id:30,children:[],}]},]},{id:2,children:[{id:9,children:[]},{id:3,children:[]},]}]

const orderChildren = obj => {
  obj.children.sort((a, b) => a.id - b.id);
  if (obj.children.some(o => o.children.length)) {
    obj.children.forEach(child => orderChildren(child));
  }
  return obj;
};

const myNewObj = myObj.map(o => orderChildren(o)).sort((a, b) => a.id - b.id);

console.log(myNewObj);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

您可以这样做：

.as-console-wrapper { max-height: 100% !important; top: 0; }

{{1}}

Answer 4

我创建了用于按 id 对嵌套数组进行排序的通用解决方案。我的解决方案适用于任何嵌套数组并根据 id 属性对其进行排序。或者通过您在方法的 seconds 参数中指定的任何其他属性。

function sortNestedArrays(obj, sortPropertyName) {
    Object.keys(obj).forEach((key) => {
        if (Array.isArray(obj[key])) {
            obj[key].sort((a, b) => a[sortPropertyName] - b[sortPropertyName]);
        }

        if (!!obj[key] && (typeof obj[key] === 'object' || Array.isArray(obj[key]))) {
            sortNestedArrays(obj[key], sortPropertyName);
        }
    });

    return obj;
}

用法如下：

obj = sortNestedArrays(obj, 'id');

按属性对整个嵌套对象进行排序javascript

4 个答案: