按键对JavaScript对象进行排序

我需要按键对JavaScript对象进行排序。

因此如下：

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

将成为：

{ 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' }
879792 次浏览
小开

JavaScript对象1没有排序。尝试对它们进行“排序”是没有意义的。如果您想迭代对象的属性，您可以对键进行排序，然后检索关联的值：

var myObj = {'b': 'asdsadfd','c': 'masdasaf','a': 'dsfdsfsdf'},keys = [],k, i, len;
for (k in myObj) {if (myObj.hasOwnProperty(k)) {keys.push(k);}}
keys.sort();
len = keys.length;
for (i = 0; i < len; i++) {k = keys[i];console.log(k + ':' + myObj[k]);}

使用Object.keys幻想的替代实现：

var myObj = {'b': 'asdsadfd','c': 'masdasaf','a': 'dsfdsfsdf'},keys = Object.keys(myObj),i, len = keys.length;
keys.sort();
for (i = 0; i < len; i++) {k = keys[i];console.log(k + ':' + myObj[k]);}

1不是迂腐，而是没有JSON对象这样的东西。

小开

这对我有用

/*** 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 keyskeys.sort();
// create new array based on Sorted KeysjQuery.each(keys, function(i, key){sorted_obj[key] = obj[key];});
return sorted_obj;};
小开

使用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 listsorted_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})
小开

如果您有嵌套对象或嵌套数组obj，请使用此代码。

var sortObjectByKey = function(obj){var keys = [];var sorted_obj = {};for(var key in obj){if(obj.hasOwnProperty(key)){keys.push(key);}}// sort keyskeys.sort();
// create new array based on Sorted KeysjQuery.each(keys, function(i, key){var val = obj[key];if(val instanceof Array){//do for loop;var arr = [];jQuery.each(val,function(){arr.push(sortObjectByKey(this));});val = arr;
}else if(val instanceof Object){val = sortObjectByKey(val)}sorted_obj[key] = val;});return sorted_obj;};
小开

如前所述，对象是无序的。

然而……

你可能会发现这个成语很有用：

var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };
var kv = [];
for (var k in o) {kv.push([k, o[k]]);}
kv.sort()

然后，您可以遍历kv并做任何您想做的事情。

> kv.sort()[ [ 'a', 'dsfdsfsdf' ],[ 'b', 'asdsad' ],[ 'c', 'masdas' ] ]
小开

很多人都提到了"对象无法排序"，但在那之后，他们给你一个有效的解决方案。悖论，不是吗？

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

我认为我们可以添加一个解决方案——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]})
小开

这个问题的其他答案已经过时，从未与实现现实相匹配，并且现在ES6/ES2015规范已经发布，正式变得不正确。

见Axel Rauschmayer在《探索ES6》中关于属性迭代顺序的部分：

所有迭代属性键的方法都以相同的顺序执行：

  1. 首先所有数组索引，按数字排序。
  2. 然后是所有字符串键（不是索引），按照它们创建的顺序。
  3. 然后是所有的符号，按照它们被创造的顺序。

所以是的，JavaScript对象是实际上是有序的，它们的键/属性的顺序可以更改。

以下是按字母顺序按键/属性对对象进行排序的方法：

const unordered = {'b': 'foo','c': 'bar','a': 'baz'};
console.log(JSON.stringify(unordered));// → '{"b":"foo","c":"bar","a":"baz"}'
const ordered = Object.keys(unordered).sort().reduce((obj, key) => {obj[key] = unordered[key];return obj;},{});
console.log(JSON.stringify(ordered));// → '{"a":"baz","b":"foo","c":"bar"}'

使用var而不是const来兼容ES5引擎。

小开

解决方案：

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 rungetSortedObject({d: 4, a: 1, b: 2, c: 3});

说明：

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

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

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

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

/*** Returns a copy of an object, which is ordered by the keys of the original object.** @param {Object} object - The original object.* @returns {Object} Copy of the original object sorted by keys.*/function getSortedObject(object) {// New object which will be returned with sorted keysvar sortedObject = {};
// Get array of keys from the old/current objectvar keys = Object.keys(object);// Sort keys (in place)keys.sort();
// Use sorted keys to copy values from old object to the new onefor (var i = 0, size = keys.length; i < size; i++) {key = keys[i];value = object[key];sortedObject[key] = value;}
// Return the new objectreturn sortedObject;}
/*** Test run*/var unsortedObject = {d: 4,a: 1,b: 2,c: 3};
var sortedObject = getSortedObject(unsortedObject);
for (var key in sortedObject) {var text = "Key: " + key + ", Value: " + sortedObject[key];var paragraph = document.createElement('p');paragraph.textContent = text;document.body.appendChild(paragraph);}

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

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

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

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

_.sortBy(myObj, "key")

此外，您要映射的第二个参数是错误的。它应该是一个函数，但使用pluck更容易。

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

也许更优雅的形式：

 /*** Sorts a key-value object by key, maintaining key to data correlations.* @param {Object} src  key-value object* @returns {Object}*/var ksort = function ( src ) {var keys = Object.keys( src ),target = {};keys.sort();keys.forEach(function ( key ) {target[ key ] = src[ key ];});return target;};

// Usageconsole.log(ksort({a:1,c:3,b:2}));

PS和ES6+语法相同：

function ksort( src ) {const keys = Object.keys( src );keys.sort();return keys.reduce(( target, key ) => {target[ key ] = src[ key ];return target;}, {});};
小开

我将一些Java枚举转移到javascript对象。

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

var Helper = {isEmpty: function (obj) {return !obj || obj === null || obj === undefined || Array.isArray(obj) && obj.length === 0;},
isObject: function (obj) {return (typeof obj === 'object');},
sortObjectKeys: function (object) {return Object.keys(object).sort(function (a, b) {c = a - b;return c});},containsItem: function (arr, item) {if (arr && Array.isArray(arr)) {return arr.indexOf(item) > -1;} else {return arr === item;}},
pushArray: function (arr1, arr2) {if (arr1 && arr2 && Array.isArray(arr1)) {arr1.push.apply(arr1, Array.isArray(arr2) ? arr2 : [arr2]);}}};
function TypeHelper() {var _types = arguments[0],_defTypeIndex = 0,_currentType,_value;
if (arguments.length == 2) {_defTypeIndex = arguments[1];}
Object.defineProperties(this, {Key: {get: function () {return _currentType;},set: function (val) {_currentType.setType(val, true);},enumerable: true},Value: {get: function () {return _types[_currentType];},set: function (val) {_value.setType(val, false);},enumerable: true}});
this.getAsList = function (keys) {var list = [];Helper.sortObjectKeys(_types).forEach(function (key, idx, array) {if (key && _types[key]) {
if (!Helper.isEmpty(keys) && Helper.containsItem(keys, key) || Helper.isEmpty(keys)) {var json = {};json.Key = key;json.Value = _types[key];Helper.pushArray(list, json);}}});return list;};
this.setType = function (value, isKey) {if (!Helper.isEmpty(value)) {Object.keys(_types).forEach(function (key, idx, array) {if (Helper.isObject(value)) {if (value && value.Key == key) {_currentType = key;}} else if (isKey) {if (value && value.toString() == key.toString()) {_currentType = key;}} else if (value && value.toString() == _types[key]) {_currentType = key;}});} else {this.setDefaultType();}return isKey ? _types[_currentType] : _currentType;};
this.setTypeByIndex = function (index) {var keys = Helper.sortObjectKeys(_types);for (var i = 0; i < keys.length; i++) {if (index === i) {_currentType = keys[index];break;}}};
this.setDefaultType = function () {this.setTypeByIndex(_defTypeIndex);};
this.setDefaultType();}

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"};console.log('keys of TypeA', Helper.sortObjectKeys(TypeA));//keys of TypeA ["-1", "2", "100", "200", "1000"]
console.log('keys of TypeB', Helper.sortObjectKeys(TypeB));//keys of TypeB ["U", "W", "V", "A", "Z", "K"]
var objectTypeA = new TypeHelper(TypeA),objectTypeB = new TypeHelper(TypeB);
console.log('list of objectA = ', objectTypeA.getAsList());console.log('list of objectB = ', 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"]
小开

这是一个古老的问题，但从Mathias Bynens的回答中得到启示，我做了一个简短的版本来对当前对象进行排序，没有太多开销。

    Object.keys(unordered).sort().forEach(function(key) {var value = unordered[key];delete unordered[key];unordered[key] = value;});

代码执行后，“无序”对象本身将按字母顺序对键进行排序。

小开

对对象进行排序的纯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 Lowestvar 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开始的数字排序的对象。

小开

这是一个干净的基于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有一个#0方法…

小开

只需使用洛塔什解压缩map和sortBy对的第一个值并再次压缩，它将返回排序的键。

如果您想将sortby值更改为1而不是

var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };console.log(_(o).toPairs().sortBy(0).fromPairs().value())

在此处输入图片描述

小开

有一个伟大的项目由@sindreshus称为排序键，工作真棒。

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

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}
小开

只是为了简化它，让它更清楚马特·鲍尔的答案

//your objectvar myObj = {b : 'asdsadfd',c : 'masdasaf',a : 'dsfdsfsdf'};
//fixed codevar 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]);}

小开 
function sortObjectKeys(obj){return Object.keys(obj).sort().reduce((acc,key)=>{acc[key]=obj[key];return acc;},{});}
sortObjectKeys({telephone: '069911234124',name: 'Lola',access: true,});
小开

递归排序，用于嵌套对象和数组

function sortObjectKeys(obj){return Object.keys(obj).sort().reduce((acc,key)=>{if (Array.isArray(obj[key])){acc[key]=obj[key].map(sortObjectKeys);}if (typeof obj[key] === 'object'){acc[key]=sortObjectKeys(obj[key]);}else{acc[key]=obj[key];}return acc;},{});}
// test itsortObjectKeys({telephone: '069911234124',name: 'Lola',access: true,cars: [{name: 'Family', brand: 'Volvo', cc:1600},{name: 'City', brand: 'VW', cc:1200,interior: {wheel: 'plastic',radio: 'blaupunkt'}},{cc:2600, name: 'Killer', brand: 'Plymouth',interior: {wheel: 'wooden',radio: 'earache!'}},]});
小开

ES6-这里是1班轮

var data = { zIndex:99,name:'sravan',age:25,position:'architect',amount:'100k',manager:'mammu' };
console.log(Object.entries(data).sort().reduce( (o,[k,v]) => (o[k]=v,o), {} ));

小开

递归排序键，同时保留引用。

function sortKeys(o){if(o && o.constructor === Array)o.forEach(i=>sortKeys(i));else if(o && o.constructor === Object)Object.entries(o).sort((a,b)=>a[0]>b[0]?1:-1).forEach(e=>{sortKeys(e[1]);delete o[e[0]];o[e[0]] = e[1];});}

示例：

let x = {d:3, c:{g:20, a:[3,2,{s:200, a:100}]}, a:1};let y = x.c;let z = x.c.a[2];sortKeys(x);console.log(x); // {a: 1, c: {a: [3, 2, {a: 1, s: 2}], g: 2}, d: 3}console.log(y); // {a: [3, 2, {a: 100, s: 200}}, g: 20}console.log(z); // {a: 100, s: 200}
小开

伙计们，我简直震惊了！当然，所有的答案都有些陈旧，但是甚至没有人提到排序的稳定性！所以请容忍我，我会尽力回答这个问题本身，并在这里详细说明。所以我要道歉，现在它会有很多阅读。

由于它是2018年，我将只使用ES6，Poly的所有可用的MDN文档，我将在给定的部分链接。

对上述问题的答复：

如果你的键只是数字，那么你可以安全地使用Object.keys()和Array.prototype.reduce()来返回排序后的对象：

// Only numbers to show it will be sorted.const testObj = {'2000': 'Articel1','4000': 'Articel2','1000': 'Articel3','3000': 'Articel4',};
// I'll explain what reduces does after the answer.console.log(Object.keys(testObj).reduce((accumulator, currentValue) => {accumulator[currentValue] = testObj[currentValue];return accumulator;}, {}));
/*** expected output:* {* '1000': 'Articel3',* '2000': 'Articel1',* '3000': 'Articel4',* '4000': 'Articel2'*  }*/
// if needed here is the one liner:console.log(Object.keys(testObj).reduce((a, c) => (a[c] = testObj[c], a), {}));

但是，如果您正在使用字符串，我强烈建议将Array.prototype.sort()链接到所有这些：

// String exampleconst testObj = {'a1d78eg8fdg387fg38': 'Articel1','z12989dh89h31d9h39': 'Articel2','f1203391dhj32189h2': 'Articel3','b10939hd83f9032003': 'Articel4',};// Chained sort into all of this.console.log(Object.keys(testObj).sort().reduce((accumulator, currentValue) => {accumulator[currentValue] = testObj[currentValue];return accumulator;}, {}));
/*** expected output:* {* a1d78eg8fdg387fg38: 'Articel1',* b10939hd83f9032003: 'Articel4',* f1203391dhj32189h2: 'Articel3',* z12989dh89h31d9h39: 'Articel2'* }*/
// again the one liner:console.log(Object.keys(testObj).sort().reduce((a, c) => (a[c] = testObj[c], a), {}));

如果有人想知道Reduce是做什么的：

// Will return Keys of object as an array (sorted if only numbers or single strings like a,b,c).Object.keys(testObj)
// Chaining reduce to the returned array from Object.keys().// Array.prototype.reduce() takes one callback// (and another param look at the last line) and passes 4 arguments to it:// accumulator, currentValue, currentIndex and array.reduce((accumulator, currentValue) => {
// setting the accumulator (sorted new object) with the actual property from old (unsorted) object.accumulator[currentValue] = testObj[currentValue];
// returning the newly sorted object for the next element in array.return accumulator;
// the empty object {} ist the initial value for  Array.prototype.reduce().}, {});

如果需要，这里是一个衬垫的解释：

Object.keys(testObj).reduce(
// Arrow function as callback parameter.(a, c) =>
// parenthesis return! so we can safe the return and write only (..., a);(a[c] = testObj[c], a)
// initial value for reduce.,{});

为什么排序有点复杂：

简而言之，Object.keys()将返回一个数组，其顺序与我们通过普通循环获得的顺序相同：

const object1 = {a: 'somestring',b: 42,c: false};
console.log(Object.keys(object1));// expected output: Array ["a", "b", "c"]

Object.keys（）返回一个元素为字符串的数组对应于直接在对象上找到的可枚举属性。属性的排序与循环给出的排序相同手动操作对象的属性。

旁注-您也可以在数组上使用Object.keys()，请记住将返回索引：

// simple arrayconst arr = ['a', 'b', 'c'];console.log(Object.keys(arr)); // console: ['0', '1', '2']

但这并不像这些例子所示的那么容易，现实世界的对象可能包含数字和字母字符甚至符号（请不要这样做）。

下面是一个例子，所有这些都在一个对象中：

// This is just to show what happens, please don't use symbols in keys.const testObj = {'1asc': '4444',1000: 'a',b: '1231','#01010101010': 'asd',2: 'c'};
console.log(Object.keys(testObj));// output: [ '2', '1000', '1asc', 'b', '#01010101010' ]

现在，如果我们在输出更改上方的数组上使用Array.prototype.sort()：

console.log(Object.keys(testObj).sort());// output: [ '#01010101010', '1000', '1asc', '2', 'b' ]

以下是来自文档的引用：

sort（）方法对数组的元素进行排序并返回数组。排序不一定是稳定的。默认排序顺序是根据字符串Unicode代码点。

排序的时间和空间复杂度不能保证实现依赖。

您必须确保其中一个为您返回所需的输出。在现实生活中的例子中，如果您同时使用不同的信息输入（如API和数据库），人们往往会特别混淆事情。

有什么大不了的？

这里有两篇文章是每个程序员都应该了解的：

就地算法：

在计算机科学中，就地算法是一种不使用辅助数据结构对输入进行转换的算法。然而，辅助变量允许少量额外的存储空间。在算法执行时，输入通常会被输出覆盖。就地算法仅通过替换或交换元素来更新输入序列。不就地的算法有时被称为非就地或非就地。

所以基本上我们的旧数组将被覆盖！如果您出于其他原因想要保留旧数组，这很重要。所以请记住这一点。

排序算法

稳定排序算法以相同的顺序对相同的元素进行排序它们出现在输入中。排序某些类型的数据时，只有部分在确定排序顺序时检查数据。例如，在右边的卡片排序示例中，卡片正在排序根据他们的等级，他们的诉讼被忽略了。这允许多个不同的正确排序版本的可能性原始列表。稳定的排序算法选择其中之一，根据以下规则：如果两个项目比较相等，如这两个5卡，那么他们的相对顺序将被保留，这样如果一个在输入中出现在另一个之前，它也会出现在另一个在输出中。

在此处输入图片描述

扑克牌稳定排序的示例。当卡片被排序时按照稳定排序，两个5必须保持相同的顺序在它们最初所在的排序输出中。当它们使用非稳定排序，5s可能以相反的顺序结束在排序的输出中。

这表明排序是正确的，但它发生了变化。因此，在现实世界中，即使排序是正确的，我们也必须确保我们得到了我们期望的！这一点非常重要，请记住这一点。有关更多JavaScript示例，请查看Array.prototype.sort（）-docs：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

小开

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

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) { ... } )
小开

现在是2019年，我们有一个2019年的方法来解决这个问题：）

Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())
小开 
Object.keys(unordered).sort().reduce((acc,curr) => ({...acc, [curr]:unordered[curr]}), {})
小开

一条线： 

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

这是一个轻量级的解决方案，我需要JSON排序的一切。

function sortObj(obj) {if (typeof obj !== "object" || obj === null)return obj;
if (Array.isArray(obj))return obj.map((e) => sortObj(e)).sort();
return Object.keys(obj).sort().reduce((sorted, k) => {sorted[k] = sortObj(obj[k]);return sorted;}, {});}
小开

最好的方法就是 

 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> ]

如果导致，则末尾的空槽，因为您的第一个索引是1而不是0。您可以使用.长度-或. pop（）删除空槽。

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

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

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

小开

我实际上非常惊讶的是，给出了30多个答案，但没有一个给出了这个问题的完整深解决方案。有些解决方案很浅，而另一些解决方案很深但有问题（如果未定义，函数或符号将在json中，它会崩溃）。

以下是完整的解决方案：

function sortObject(unordered, sortArrays = false) {if (!unordered || typeof unordered !== 'object') {return unordered;}
if (Array.isArray(unordered)) {const newArr = unordered.map((item) => sortObject(item, sortArrays));if (sortArrays) {newArr.sort();}return newArr;}
const ordered = {};Object.keys(unordered).sort().forEach((key) => {ordered[key] = sortObject(unordered[key], sortArrays);});return ordered;}
const json = {b: 5,a: [2, 1],d: {b: undefined,a: null,c: false,d: true,g: '1',f: [],h: {},i: 1n,j: () => {},k: Symbol('a')},c: [{b: 1,a: 1}]};console.log(sortObject(json, true));
小开

这是一个单行解决方案（不是最有效的，但当涉及到像您的示例中这样的瘦对象时，我宁愿使用本机JS函数，也不愿使用草率的循环）

const unordered = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }
const ordered = Object.fromEntries(Object.entries(unordered).sort())
console.log(ordered); // a->b->c

小开 
// if keys are char/stringconst sortObject = (obj) => Object.fromEntries(Object.entries(obj).sort( ));let obj = { c: 3, a: 1 };obj = sortObject(obj)
// if keys are numbersconst sortObject = (obj) => Object.fromEntries(Object.entries(obj).sort( (a,b)=>a-b ));let obj = { 3: 'c', 1: 'a' };obj = sortObject(obj)
小开

我喜欢上面的这个aswer，除了它不起作用：

/*** 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 keyskeys.sort();
// create new array based on Sorted KeysjQuery.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 keyskeys.sort();
// create new map based on Sorted Keyskeys.forEach(key => {sorted_map.set(key, obj[key]);});
return sorted_map;};
小开 

const sortObjectByKeys = (object, asc = true) => Object.fromEntries(Object.entries(object).sort(([k1], [k2]) => k1 < k2 ^ !asc ? -1 : 1),)
const object = { b: 'asdsad', c: 'masdas', a: 'dsfdsfsdf' }
const orderedObject = sortObjectByKeys(object)
console.log(orderedObject)


提交答案