按键排序JavaScript对象

一句话概括：

Object.entries(unordered)
  .sort(([keyA], [keyB]) => keyA > keyB)
  .reduce((obj, [key,value]) => Object.assign(obj, {[key]: value}), {})

Object.fromEntries(Object.entries(obj).sort(([a],[b]) => a.localeCompare(b)))

使用纯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;
}

我喜欢上面的答案，但它不起作用：

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

看起来排序后的对象没有顺序保证，因此使用映射表似乎更合适。我最终将对象更改为映射表，类似于以下内容：

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

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

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

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

只是为了简化并使Matt Ball的回答更加清晰

//your object
var myObj = {
    b : 'asdsadfd',
    c : 'masdasaf',
    a : 'dsfdsfsdf'
  };

//fixed code
var keys = [];
for (var k in myObj) {
  if (myObj.hasOwnProperty(k)) {
    keys.push(k);
  }
}
keys.sort();
for (var i = 0; i < keys.length; i++) {
  k = keys[i];
  alert(k + ':' + myObj[k]);
}

不确定这是否回答了问题，但这正是我所需要的。

Maps.iterate.sorted = function (o, callback) {
    var keys = Object.keys(o), sorted = keys.sort(), k; 
    if ( callback ) {
            var i = -1;
            while( ++i < sorted.length ) {
                    callback(k = sorted[i], o[k] );
            }
    }

    return sorted;
}

Maps.iterate.sorted({c:1, b:2, a:100}, function(k, v) { ... } ) 

所选答案未考虑嵌套的 JSON 对象情况。

要按键对具有嵌套子项的对象进行排序，需要递归地对该对象进行排序：

function sortObjectByKeyDeep(obj) {
  const sortedObj = {};
  const keys = Object.keys(obj).sort();

  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const value = obj[key];

    if (typeof value === "object" && !Array.isArray(value)) {
      sortedObj[key] = sortObjectByKeyDeep(value);
    } else if (Array.isArray(value)) {
      sortedObj[key] = value.map((item) =>
        typeof item === "object" ? sortObjectByKeyDeep(item) : item
      );
    } else {
      sortedObj[key] = value;
    }
  }

  return sortedObj;
}

测试用例：

const myObj = {
  c: 1,
  b: {
    d: 2,
    a: 3,
  },
  e: [
    {
      g: 4,
      f: 5,
    },
    {
      i: 6,
      h: 7,
    },
  ],
};

const sortedObj = sortObjectByKeyDeep(myObj);
console.log(sortedObj);
// Output: {b: {a: 3, d: 2}, c: 1, e: [{f: 5, g: 4}, {h: 7, i: 6}]}