这对我有用

/**
 * Return an Object sorted by it's Key
 */
var sortObjectByKey = function(obj){
    var keys = [];
    var sorted_obj = {};

    for(var key in obj){
        if(obj.hasOwnProperty(key)){
            keys.push(key);
        }
    }

    // sort keys
    keys.sort();

    // create new array based on Sorted Keys
    jQuery.each(keys, function(i, key){
        sorted_obj[key] = obj[key];
    });

    return sorted_obj;
};

假设它在显示无序对象财产的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})

@sindresorhus有一个很棒的项目，叫做排序键，非常棒。

您可以在此处查看其源代码：

https://github.com/sindresorhus/sort-keys

或者您可以将其与npm一起使用：

$ npm install --save sort-keys

以下也是他的自述文件中的代码示例

const sortKeys = require('sort-keys');

sortKeys({c: 0, a: 0, b: 0});
//=> {a: 0, b: 0, c: 0}

sortKeys({b: {b: 0, a: 0}, a: 0}, {deep: true});
//=> {a: 0, b: {a: 0, b: 0}}

sortKeys({c: 0, a: 0, b: 0}, {
    compare: (a, b) => -a.localeCompare(b)
});
//=> {c: 0, b: 0, a: 0}

我喜欢上面的这个，只是它不起作用：

/**
 * Return an Object sorted by it's Key
 */
var sortObjectByKey = function(obj){
    var keys = [];
    var sorted_obj = {};

    for(var key in obj){
        if(obj.hasOwnProperty(key)){
            keys.push(key);
        }
    }

    // sort keys
    keys.sort();

    // create new array based on Sorted Keys
    jQuery.each(keys, function(i, key){
        sorted_obj[key] = obj[key];
    });

    return sorted_obj;
};

看起来像sorted_obj，没有秩序的保证，因为那张地图似乎更适合，我最终改变了地图的对象，类似这样：

/**
 * Return an Object sorted by it's Key
 */
var sortObjectByKey = function(obj){
    var keys = [];
    let sorted_map = new Map();

    for(var key in obj){
        if(obj.hasOwnProperty(key)){
            keys.push(key);
        }
    }

    // sort keys
    keys.sort();

    // create new map based on Sorted Keys
    keys.forEach(key => {
        sorted_map.set(key, obj[key]);
    });

    return sorted_map;
};

解决方案：

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

对Object进行排序的纯JavaScript答案。这是我所知道的唯一能处理负数的答案。此函数用于对数字对象进行排序。

输入obj＝｛1000:｛｝，-1200:｛｝，10000:｛}，200:｝｝；

function osort(obj) {
var keys = Object.keys(obj);
var len = keys.length;
var rObj = [];
var rK = [];
var t = Object.keys(obj).length;
while(t > rK.length) {
    var l = null;
    for(var x in keys) {
        if(l && parseInt(keys[x]) < parseInt(l)) {
            l = keys[x];
            k = x;
        }
        if(!l) { // Find Lowest
            var l = keys[x];
            var k = x;
        }
    }
    delete keys[k];
    rK.push(l);
}

for (var i = 0; i < len; i++) {

    k = rK[i];
    rObj.push(obj[k]);
}
return rObj;
}

输出将是一个按这些数字排序的对象，新键从0开始。