Javascript: Sorting Objects (not arrays) in descending

Question

I know objects are by default sorted out in ascending order or the way we will insert but I need the best way to sort the object in descending order. Ex:

Input x = {
 a: {},
 b: {},
 c: {},
 d: {}
}
Output: x = {
 d: {},
 c: {},
 b: {},
 a: {}
}

I tried the below solution, It works but is it a good practice or can I get anything better on this?

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

• James: Object properties don't have a guaranteed order, like array elements do.
• Get Off My Lawn: Maybe sort them first: Object.keys(x).sort((a, b) => b.localeCompare(a)).reduce()
• James: You can't reliably sort something that doesn't have a guaranteed order. Use arrays if you need them sorted!
• RobG: @James—since ECMAScript 2017 they do, see the abstract operation OrdinaryOwnPropertyKeys which is used by various methods when accessing property names. However not all implementations in use may be compliant.
• Santi: @James That is no longer true. Javascript objects do have guaranteed order, assuming your key names aren't positive integer values. I would never recommend using an object for anything reliant on order, but the notion that "object properties don't have a guaranteed order" is misinformation.

Answer 1

You can use the Array.sort method. I believe this will only sort on the first level depth

 const list = 
 { 
 a: "4",
 c: "2",
 b: "3",
 d: "1"
 }
 const sortedList = {};
 Object.keys(list).sort().reverse().forEach(function(key) {
 sortedList[key] = list[key];
 });

• RobG: See the comment on zer00ne's answer above.

Answer 2

Use a Map to guarantee order while using Object.entries() method to preserve key/value pairs.

• Get an array of arrays from Object.entries()
• .reverse() it
• Convert it into a Map (Map() guarantees order according to how it was entered)
• Use Object.fromEntries() on Map to return an object.

let obj = {a:{}, b:{}, c:{}, d:{}};
let rev = new Map(Object.entries(obj).reverse());
let ent = Object.fromEntries(rev);
console.log(ent);

See compatibility table for Object.fromEntries()

• RobG: You can't enforce a particular sorting in general. Since ECMAScript 2017, the order is positive integer keys in ascending numeric order, then strings that aren't symbols in insertion order, then symbols in insertion order. So you can't order integer keys in descending order and can't mix integers, strings and symbols. The abstract operation OrdinaryOwnPropertyKeys is used by everything that gets keys.
• zer00ne: I thought Object.entries() returns [[key, value], [ley, value],...] in this case key turns into a string. And Map() accepts anything as a key in insertion order. Oh, the .sort() is useless then? Will update.