Мне нужно отсортировать объекты JavaScript по ключу.
Отсюда следует:
{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }
Стало бы:
{ 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' }
Сортировка объекта JavaScript по ключу
Ответ 1
Другие ответы на этот вопрос устарели, никогда не соответствовали реальности реализации и официально стали неверными после публикации спецификации ES6/ES2015.
См. Раздел, посвященный порядку итераций свойств в " Изучении ES6 " Акселя Раушмайера:
Все методы, которые перебирают ключи свойств, делают это в том же порядке:
- Сначала все индексы Array, отсортированные по номерам.
- Затем все строковые ключи (которые не являются индексами), в том порядке, в котором они были созданы.
- Затем все символы в том порядке, в котором они были созданы.
Так что да, объекты 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().forEach(function(key) {
ordered[key] = unordered[key];
});
console.log(JSON.stringify(ordered));
// → '{"a":"baz","b":"foo","c":"bar"}'Ответ 2
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]);
}Ответ 3
Многие люди отмечают, что "объекты не могут быть отсортированы" , но после этого они дают вам решение, которое работает. Парадокс, не так ли?
Никто не упоминает, почему эти решения работают. Они есть, потому что в большинстве версий реализации браузера значения в объектах хранятся в том порядке, в котором они были добавлены. Поэтому, если вы создаете новый объект из отсортированного списка ключей, он возвращает ожидаемый результат.
И я думаю, что мы могли бы добавить еще одно решение - функциональный способ ES5:
function sortObject(obj) {
return Object.keys(obj).sort().reduce(function (result, key) {
result[key] = obj[key];
return result;
}, {});
}
Версия ES2015 выше (отформатирована на "однострочный" ):
function sortObject(o) {
return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {});
}
Краткое объяснение приведенных выше примеров (как указано в комментариях):
Object.keys дает нам список ключей в предоставленном объекте (obj или o), затем мы сортируем тех, которые используют алгоритм сортировки по умолчанию, а затем .reduce используется для преобразования этого массива обратно в объект, но на этот раз со всеми сортированными ключами.
Ответ 4
Ребята, я образно шокирован! Конечно, все ответы несколько устарели, но никто даже не упомянул стабильность в сортировке! Так что терпите меня, я сделаю все возможное, чтобы ответить на сам вопрос и вдаваться в подробности здесь. Поэтому я собираюсь извиниться, сейчас будет много чего читать.
Поскольку это 2018 год, я буду использовать только ES6, все полифилы доступны в документах 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 example
const 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), {}));
Если кому-то интересно, что делает сокращение:
// 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.
,{}
);
- Документы для сокращения: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
- Зачем использовать круглые скобки в операторах возврата JavaScript: http://jamesknelson.com/javascript-return-parenthesis/
Почему сортировка немного сложна:
Короче говоря, Object.keys() вернет массив в том же порядке, в каком мы получаем обычный цикл:
const object1 = {
a: 'somestring',
b: 42,
c: false
};
console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]
Object.keys() возвращает массив, элементы которого являются строками соответствующие перечисляемым свойствам, найденным непосредственно на объекте. Порядок свойств такой же, как и в цикле над свойствами объекта вручную.
Sidenote - вы также можете использовать Object.keys() для массивов, помните, что индекс будет возвращен:
// simple array
const 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() сортирует элементы массива на месте и возвращает массив. Сортировка не обязательно стабильна. Порядок сортировки по умолчанию соответствует строковым кодовым точкам Юникода.
Пространственно-временная сложность не может быть гарантирована, так как зависит от реализации.
Вы должны убедиться, что один из них возвращает желаемый результат для вас. В реальных примерах люди склонны смешивать вещи, особенно если вы используете разные информационные входы, такие как API и базы данных.
Так в чем же дело?
Ну, есть две статьи, которые должен понять каждый программист:
В компьютерной науке алгоритм на месте - это алгоритм, который преобразует входные данные без использования вспомогательной структуры данных. Однако для вспомогательных переменных допускается небольшое количество дополнительного пространства для хранения. Входные данные обычно перезаписываются выходными данными при выполнении алгоритма. Алгоритм на месте обновляет входную последовательность только путем замены или замены элементов. Алгоритм, который не на месте, иногда называют не на месте или не на месте.
Так что в основном наш старый массив будет перезаписан! Это важно, если вы хотите сохранить старый массив по другим причинам. Так что имейте это в виду.
Стабильные алгоритмы сортировки сортируют идентичные элементы в том же порядке, что они появляются на входе. При сортировке некоторых видов данных, только часть данных проверяется при определении порядка сортировки. Например, в примере сортировки карт справа карты сортируются их рангом, и их иск игнорируется. Это позволяет возможность нескольких разных правильно отсортированных версий Оригинальный список. Стабильные алгоритмы сортировки выбирают один из них, согласно следующему правилу: если два элемента сравниваются как равные, как две 5 карт, то их относительный порядок будет сохранен, так что если один вход перед другим на входе, он также будет предшествовать другой на выходе.
Пример стабильной сортировки по игральным картам. Когда карты отсортированы по рангу со стабильной сортировкой, две 5 должны оставаться в том же порядке в отсортированном выводе, в котором они были изначально. Когда они отсортированные с нестабильной сортировкой, 5 могут оказаться в обратном порядке в отсортированном выводе.
Это показывает, что сортировка верна, но она изменилась. Таким образом, в реальном мире, даже если сортировка правильная, мы должны убедиться, что получаем то, что ожидаем! Это очень важно, имейте это в виду. Дополнительные примеры JavaScript можно найти в Array.prototype.sort() - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
Ответ 5
Это работает для меня
/**
* Return an Object sorted by it 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;
};
Ответ 6
Это старый вопрос, но, отвечая на вопрос Матиаса Биненса, я сделал короткую версию, чтобы отсортировать объект current без особых накладных расходов.
Object.keys(unordered).sort().forEach(function(key) {
var value = unordered[key];
delete unordered[key];
unordered[key] = value;
});
после выполнения кода сам объект "неупорядоченный" будет иметь сортировку по алфавиту.
Ответ 7
вот 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), {} ));Ответ 8
Использование 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();
Просто пища для размышлений.
Ответ 9
Предположим, что это может быть полезно в отладчике VisualStudio, который показывает неупорядоченные свойства объекта.
(function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3})
Ответ 10
Это 2019 год, и у нас есть 2019 способ решить эту проблему :)
Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())
Ответ 11
function order(unordered)
{
return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]}));
}
Если вы не доверяете своему браузеру сохранению порядка ключей, я настоятельно рекомендую полагаться на упорядоченный массив парных массивов с ключом.
_.sortBy(_.pairs(c),function(o){return o[0]})
Ответ 12
Может быть, немного более элегантная форма:
/**
* 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;
};
// Usage
console.log(ksort({
a:1,
c:3,
b:2
}));Ответ 13
function sortObjectKeys(obj){
return Object.keys(obj).sort().reduce((acc,key)=>{
acc[key]=obj[key];
return acc;
},{});
}
sortObjectKeys({
telephone: '069911234124',
name: 'Lola',
access: true,
});
Ответ 14
рекурсивная сортировка для вложенных объектов и массивов
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 it
sortObjectKeys({
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!'
}
},
]
});
Ответ 15
Как уже упоминалось, объекты неупорядочены.
Однако...
Вы можете найти эту идиому полезной:
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' ] ]
Ответ 16
Вот чистая версия на основе 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() method...
Ответ 17
Просто используйте lodash, чтобы распаковать карту и sortBy первое значение пары и zip снова вернет отсортированный ключ.
Если вы хотите, чтобы индекс сортировки сменил индекс пары на 1 вместо 0
var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };
console.log(_(o).toPairs().sortBy(0).fromPairs().value())
Ответ 18
Используйте этот код, если у вас есть вложенные объекты или у вас есть вложенный массив obj.
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){
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;
};
Ответ 19
Решение:
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(), который сортирует элементы массива на месте (нет необходимости назначьте их новой переменной).
После сортировки ключей вы можете начать использовать их один за другим, чтобы получить доступ к содержимому старого объекта, чтобы заполнить новый объект (который теперь отсортирован).
Ниже приведен пример процедуры (вы можете протестировать ее в целевых браузерах):
/**
* 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 keys
var sortedObject = {};
// Get array of keys from the old/current object
var keys = Object.keys(object);
// Sort keys (in place)
keys.sort();
// Use sorted keys to copy values from old object to the new one
for (var i = 0, size = keys.length; i < size; i++) {
key = keys[i];
value = object[key];
sortedObject[key] = value;
}
// Return the new object
return 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);
}Ответ 20
Простой и читаемый фрагмент, используя lodash.
Вам нужно поставить ключ в кавычки только при вызове sortBy. Он не должен быть в кавычках в самих данных.
_.sortBy(myObj, "key")
Кроме того, ваш второй параметр для карты неверен. Это должна быть функция, но проще использовать скребок.
_.map( _.sortBy(myObj, "key") , "value");
Ответ 21
Я перенес некоторые перечисления Java в объекты javascript.
Эти объекты вернули мне правильные массивы. если объектные ключи имеют смешанный тип (строка, 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());Ответ 22
Там отличный проект @sindresorhus, называемый сортировочными клавишами, который работает потрясающе.
Здесь вы можете проверить его исходный код:
https://github.com/sindresorhus/sort-keys
Или вы можете использовать его с npm:
$ npm install --save sort-keys
Вот примеры кода из его readme
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}
Ответ 23
Сортирует ключи рекурсивно, сохраняя ссылки.
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}
Ответ 24
Очень хороший пример сортировки ключей объектов здесь: Итерация по ассоциативному массиву Javascript в отсортированном порядке
Ответ 25
Чистый ответ JavaScript для сортировки объекта. Это единственный ответ, который, как я знаю, будет обрабатывать отрицательные числа. Эта функция предназначена для сортировки числовых объектов.
Input 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.
Ответ 26
Просто, чтобы упростить его и сделать более понятным ответ от 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]);
}Ответ 27
Object.keys(unordered).sort().reduce(
(acc,curr) => ({...acc, [curr]:unordered[curr]})
, {}
)
Ответ 28
Не уверен, что это отвечает на вопрос, но это то, что мне было нужно.
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) { ... } )
Ответ 29
Одна строка:
Object.entries(unordered)
.sort(([keyA], [keyB]) => keyA > keyB)
.reduce((obj, [key,value]) => Object.assign(obj, {[key]: value}), {})
Ответ 30
Это простое решение для всего, что мне нужно для сортировки 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;
}, {});
}