最好的方法是

 const object =  Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})

 //else if its in reverse just do 

 const object = Object.keys(0).reverse ()

您可以首先将几乎类似数组的对象转换为实际数组，然后使用.reverse（）：

Object.assign([], {1:'banana', 2:'apple', 
3:'orange'}).reverse();
// [ "orange", "apple", "banana", <1 empty slot> ]

结尾处的空槽if cause，因为第一个索引是1而不是0。可以使用.length--或.pop（）删除空槽。

或者，如果您想借用.reverse并在同一个对象上调用它，它必须是一个完全类似数组的对象。也就是说，它需要长度属性：

Array.prototype.reverse.call({1:'banana', 2:'apple', 
3:'orange', length:4});
// {0:"orange", 1:"apple", 3:"banana", length:4}

注意，它将返回同一个完全类似数组的对象对象，因此它不是一个真正的数组。然后可以使用delete删除长度属性。

简单易读的代码段，使用lodash。

只有在调用sortBy时，才需要将键放在引号中。它不必在数据本身的引号中。

_.sortBy(myObj, "key")

另外，要映射的第二个参数是错误的。这应该是一种功能，但使用勇气更容易。

_.map( _.sortBy(myObj, "key") , "value");

ES6-这是1内衬

var数据＝{zIndex:99，名称：“Ravan”，年龄：25岁，位置：“架构”，金额：'100k'，经理：‘ammu’}；console.log（Object.entries（data）.sort（）.reduce（（o，[k，v]）=>（o[k]=v，o），{}））；

我将一些Java枚举转换为javascript对象。

这些对象为我返回了正确的数组。如果对象键是混合类型（string、int、char），则存在问题。

var助手={isEmpty：函数（obj）{回来obj | | obj===null | | obj===未定义| | Array.isArray（obj）&&obj.length===0；},isObject：函数（obj）{return（对象类型==“object”）；},sortObjectKeys:函数（对象）{return Object.keys（对象）.sort（函数（a，b）{c=a-b；返回c});},containsItem:函数（arr，item）{if（arr&&Array.isArray（arr））{return arr.indexOf（项）>-1；}其他{返回arr==项；}},pushArray：函数（arr1，arr2）{if（arr1&&arr2&&Array.isArray（arr1））{arr1.push.apply（arr1，Array.isArray（arr2）？arr2:[arr2]）；}}};函数TypeHelper（）{var_types=参数[0]，_defTypeIndex＝0，_电流类型，_价值；if（arguments.length==2）{_defTypeIndex=参数[1]；}对象定义属性（this{关键字：{get:函数（）{return _currentType；},集合：函数（val）{_currentType.setType（val，true）；},可枚举：真},值：{get:函数（）{返回类型[_currentType]；},集合：函数（val）{_value.setType（val，false）；},可枚举：真}});this.getAsList=函数（键）{var列表=[]；Helper.sortObjectKeys（_types）.forEach（函数（键、idx、数组）{if（键和类型[key]）{if（！Helper.isEmpty（keys）&&Helper.containsItem（keys，key）|| Helper.isEmpty（key））{var json=｛｝；json.Key=密钥；json.Value=_types[key]；Helper.pushArray（列表，json）；}}});返回列表；};this.setType=函数（值，isKey）{if（！Helper.isEmpty（value））{Object.keys（_types）.forEach（函数（key，idx，array）{if（Helper.isObject（值））{if（value&&value.Key==Key）{_currentType=键；}}else if（isKey）{if（value&&value.toString（）==key.toString（））{_currentType=键；}}否则如果（value&&value.toString（）==_types[key]）{_currentType=键；}});}其他{this.setDefaultType（）；}return isKey_类型[_currentType]：_currentType；};this.setTypeByIndex=函数（索引）{var keys=Helper.sortObjectKeys（_types）；对于（var i=0；i<keys.length；i++）{如果（索引==i）{_currentType=键[index]；打破}}};this.setDefaultType=函数（）{this.setTypeByIndex（_defTypeIndex）；};this.setDefaultType（）；}变量类型A={“-1”：“任意”，“2”：“2L”，“100”：“100L”，“200”：“200L”，“1000”：“1000升”};变量类型B={“U”：“任意”，“W”：“1L”，“V”：“2L”，“A”：“100L”，“Z”：“200L”，“K”：“1000L”};console.log（'keys of TypeA'，Helper.sortObjectKeys（TypeA））//A类钥匙[“-1”、“2”、“100”、“200”、“1000”]console.log（'keys of TypeB'，Helper.sortObjectKeys（TypeB））//B类键[“U”、“W”、“V”、“A”、“Z”、“K”]var objectTypeA=新TypeHelper（TypeA），objectTypeB=新的TypeHelper（TypeB）；console.log（'listofobjectA='，objectTypeA.getAsList（））；console.log（'listofobjectB='，objectTypeB.getAsList（））；

Types:

var TypeA = {
    "-1": "Any",
    "2": "2L",
    "100": "100L",
    "200": "200L",
    "1000": "1000L"
};

var TypeB = {
    "U": "Any",
    "W": "1L",
    "V": "2L",
    "A": "100L",
    "Z": "200L",
    "K": "1000L"
};


Sorted Keys(output):

Key list of TypeA -> ["-1", "2", "100", "200", "1000"]

Key list of TypeB -> ["U", "W", "V", "A", "Z", "K"]

很多人都提到“对象无法排序”，但在那之后，他们给了你一个可行的解决方案。矛盾，不是吗？

没有人提及这些解决方案为何奏效。它们是这样的，因为在大多数浏览器的实现中，对象中的值是按照添加它们的顺序存储的。这就是为什么如果您从排序的键列表中创建新对象，它将返回预期结果。

我认为我们可以再增加一个解决方案——ES5功能方式：

function sortObject(obj) {
    return Object.keys(obj).sort().reduce(function (result, key) {
        result[key] = obj[key];
        return result;
    }, {});
}

上述ES2015版本（格式为“一行”）：

const sortObject = o => Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})

上述示例的简短解释（如评论中所要求的）：

Object.keys为我们提供了所提供对象（obj或o）中的键列表，然后我们使用默认排序算法对这些键进行排序，接下来使用reduce将数组转换回对象，但这次对所有键进行了排序。

核心版本：

function order(unordered)
{
return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]}));
}

如果你不信任你的浏览器来保持键的顺序，我强烈建议你依赖一个键值配对数组的有序数组。

_.sortBy(_.pairs(c),function(o){return o[0]})