Javascript 在嵌套对象中按键排序对象

Question

I have the following object:

{
  4: {
    1: [
      { order: 1, name: 'Test 4' }
    ]
  },
  0: {
    15: [
      { order: 7, name: 'Test 1' },
      { order: 3, name: 'Test 3' },
    ],
    12: { 
      { order: 1, name: 'Test 2' }
    }
  }
}

Essentially what I am trying to achieve is to order this by the keys and then order further by the order property from within the nested value. So in turn I get the following output:

{
  0: {
    12: { 
      { order: 1, name: 'Test 2' }
    },
    15: [
      { order: 3, name: 'Test 3' },
      { order: 7, name: 'Test 1' },
    ]
  },
  4: {
    1: [
      { order: 1, name: 'Test 4' }
    ]
  }
}

I then want to completely flatten this so it's without any of the outer object and just the data within the order, the outcome would then be:

[
  { name: 'Test 2' },
  { name: 'Test 3' },
  { name: 'Test 1' },
  { name: 'Test 4' }
]

I imagine this would be some kind of recursive operation which I need to do and I originally did it with something like the following but it got a bit messy:

Object.keys(obj)
  .sort()
  .reduce((acc, key) => { acc[key] = obj[key]; return acc; }, {});

Answer 1

You can sort each obj by keys using Object.keys(obj).sort() and then access each element by its key.

Do this 2 times to get the array of object

 const obj = { 4: { 1: [ { order: 1, name: 'Test 4' } ] }, 0: { 15: [ { order: 7, name: 'Test 1' }, { order: 3, name: 'Test 3' }, ], 12: [ { order: 1, name: 'Test 2' } ] } } let flatItems = [] const keys = Object.keys(obj).sort() for (const key of keys){ const subObj = obj[key] const subKeys = Object.keys(subObj).sort() for(const subKey of subKeys){ flatItems = flatItems.concat(subObj[subKey].sort((a, b) => a.order - b.order)) } } console.log(flatItems)

Answer 2

Object keys can't easily be sorted, the iteration order depends on different rules and isn't straightforward to work with. As a result you're better off converting your object into an array of key-value pair arrays (entries), and then sort that array rather than trying to sort your object.

To do this, you can create a recursive function ( sortEntries ) that takes your object and grabs the entries from it. Using the key component of the entries, you can sort based on that. Once you've sorted the entries, you can .flatMap() the result of recursively sorting your nested object value by calling the sortEntries function again. For the base case (termination case), you can stop the recursion once you've found a value that is an array, which for that you can sort by the order property for your objects and then .map() each object to extract only the name property. Each array returned by .map() will be merged together into one resulting array due to the previous .flatMap() call:

 const obj = { 4: { 1: [ { order: 1, name: 'Test 4' } ] }, 0: { 15: [ { order: 7, name: 'Test 1' }, { order: 3, name: 'Test 3' }, ], 12: [ { order: 1, name: 'Test 2' } ] } }; const sortEntries = (obj) => { return Array.isArray(obj)? obj.slice().sort((a, b) => a.order - b.order).map(({name}) => ({name})): Object.entries(obj).sort(([a], [b]) => a - b).flatMap(([, val]) => sortEntries(val)); } const res = sortEntries(obj); console.log(res);

Answer 3

Anotner one sorting approach

 const obj = {4:{1:[{order:1,name:'Test 4'}]},0:{15:[{order:7,name:'Test 1'},{order:3,name:'Test 3'},],12:[{order:1,name:'Test 2'}]}}; const result = Object.entries(obj).flatMap(([u1, v1]) => Object.entries(v1).flatMap(([u2, v2]) => v2.map((v3) => ({ key: u1*1_000 + u2 + v3.order/1_000, item: v3 })) ) ).sort(({ key: a }, { key: b }) => a - b).map(({ item }) => item); console.log(result);

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

Answer 4

The integer properties (in the range of 32 bit unsigned integers) don't need sorting, as iteration over them (eg via Object.values ) is by specification already sorted by those integer keys. So the logic needs to focus only on sorting the inner objects, and it will be fine.

 const flatSort = obj => Array.isArray(obj)? [...obj].sort((a, b) => a.order - b.order).map(a => a.name): Object.values(obj).flatMap(flatSort); const obj = { 4: { 1: [ { order: 1, name: 'Test 4' } ] }, 0: { 15: [ { order: 7, name: 'Test 1' }, { order: 3, name: 'Test 3' }, ], 12: [ { order: 1, name: 'Test 2' } ] } }; const res = flatSort(obj); console.log(res);

Answer 5

Full Key/Value object sorting (array values included):

function sortKeys(object) {
  if (Array.isArray(object))
    return object.sort().map((obj) => (typeof obj === "object" ? sortKeys(obj) : obj));

  const sortedObj = {};
  const keys = Object.keys(object).sort();

  for (var index in keys) {
    const key = keys[index];
    if (typeof object[key] === "object") {
      sortedObj[key] = sortKeys(object[key]);
    } else {
      sortedObj[key] = object[key];
    }
  }

  return sortedObj;
}