ES6-这是1内衬

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

这里是一个基于lodash的干净版本，可以处理嵌套对象

/**
 * Sort of the keys of an object alphabetically
 */
const sortKeys = function(obj) {
  if(_.isArray(obj)) {
    return obj.map(sortKeys);
  }
  if(_.isObject(obj)) {
    return _.fromPairs(_.keys(obj).sort().map(key => [key, sortKeys(obj[key])]));
  }
  return obj;
};

如果lodash有一个toObject（）方法，它会更干净。。。

使用lodash可以：

some_map = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }

// perform a function in order of ascending key
_(some_map).keys().sort().each(function (key) {
  var value = some_map[key];
  // do something
});

// or alternatively to build a sorted list
sorted_list = _(some_map).keys().sort().map(function (key) {
  var value = some_map[key];
  // return something that shall become an item in the sorted list
}).value();

只是思考的食物。

假设它在显示无序对象财产的VisualStudio调试器中很有用。

(function(s) {
    var t = {};

    Object.keys(s).sort().forEach(function(k) {
        t[k] = s[k]
    });

    return t
})({
    b: 2,
    a: 1,
    c: 3
});

与内联版本相同：

(function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3})

我将一些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"]

解决方案：

function getSortedObject(object) {
  var sortedObject = {};

  var keys = Object.keys(object);
  keys.sort();

  for (var i = 0, size = keys.length; i < size; i++) {
    key = keys[i];
    value = object[key];
    sortedObject[key] = value;
  }

  return sortedObject;
}

// Test run
getSortedObject({d: 4, a: 1, b: 2, c: 3});

说明：

许多JavaScript运行时将值按添加顺序存储在对象内。

要按键对对象的财产进行排序，可以使用object.keys函数，该函数将返回键数组。然后可以通过array.prototype.sort（）方法对键数组进行排序，该方法对数组中的元素进行排序（无需将它们分配给新变量）。

键排序后，您可以开始逐个使用它们来访问旧对象的内容，以填充新对象（现在已排序）。

以下是该过程的示例（您可以在目标浏览器中进行测试）：

/***返回对象的副本，该副本按原始对象的键排序。**@param｛Object｝Object-原始对象。*@返回｛Object｝按关键字排序的原始对象的副本。*/函数getSortedObject（对象）{//将返回带有排序键的新对象var sortedObject=｛｝；//从旧/当前对象获取密钥数组var keys=对象.keys（对象）；//排序键（在位）keys.sort（）；//使用排序键将值从旧对象复制到新对象for（var i=0，size=keys.length；i<size；i++）{key=键[i]；value=对象[key]；sortedObject[key]=值；}//返回新对象return sortedObject；}/***试运行*/var unsortedObject={d： 4中，a： 1中，b： 2，c： 3个};var sortedObject=getSortedObject（未排序对象）；for（sortedObject中的var键）{var text=“Key:”+Key+“，Value:”+sortedObject[Key]；var段落=document.createElement（'p'）；paragraph.textContent=text；document.body.appendChild（段落）；}

注意：Object.keys是一个ECMAScript 5.1方法，但这里有一个用于旧浏览器的polyfill：

if (!Object.keys) {
  Object.keys = function (object) {
    var key = [];
    var property = undefined;
    for (property in object) {
      if (Object.prototype.hasOwnProperty.call(object, property)) {
        key.push(property);
      }
    }
    return key;
  };
}