Javascript sort object by key within nested objects

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;
}

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)

The integer properties (in the range of 32 bit unsigned integers) don't need sorting, as iteration over them (e.g. 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);

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 (sorting is required as your object can have non-array index keys such as -1).

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);