By vdh_ant


2011-03-29 02:08:51 8 Comments

I need to sort JavaScript objects by key.

Hence the following:

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

Would become:

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

29 comments

@Alan Hape 2019-10-17 22:33:35

This is a lightweight solution to everything I need for JSON sorting.

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;
    }, {});
}

@Megajin 2018-08-07 11:13:25

Guys I'm figuratively shocked! Sure all answers are somewhat old, but no one did even mention the stability in sorting! So bear with me I'll try my best to answer the question itself and go into details here. So I'm going to apologize now it will be a lot to read.

Since it is 2018 I will only use ES6, the Polyfills are all available at the MDN docs, which I will link at the given part.


Answer to the question:

If your keys are only numbers then you can safely use Object.keys() together with Array.prototype.reduce() to return the sorted object:

// 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), {}));

However if you are working with strings I highly recommend chaining Array.prototype.sort() into all of this:

// 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), {}));

If someone is wondering what reduce does:

// 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().
}, {});

If needed here is the explanation for the one liner:

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.
  ,{}
);

Why Sorting is a bit complicated:

In short Object.keys() will return an array with the same order as we get with a normal loop:

const object1 = {
  a: 'somestring',
  b: 42,
  c: false
};

console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]

Object.keys() returns an array whose elements are strings corresponding to the enumerable properties found directly upon object. The ordering of the properties is the same as that given by looping over the properties of the object manually.

Sidenote - you can use Object.keys() on arrays as well, keep in mind the index will be returned:

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

But it is not as easy as shown by those examples, real world objects may contain numbers and alphabetical characters or even symbols (please don't do it).

Here is an example with all of them in one object:

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

Now if we use Array.prototype.sort() on the array above the output changes:

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

Here is a quote from the docs:

The sort() method sorts the elements of an array in place and returns the array. The sort is not necessarily stable. The default sort order is according to string Unicode code points.

The time and space complexity of the sort cannot be guaranteed as it is implementation dependent.

You have to make sure that one of them returns the desired output for you. In reallife examples people tend to mix up things expecially if you use different information inputs like APIs and Databases together.


So what's the big deal?

Well there are two articles which every programmer should understand:

In-place algorithm:

In computer science, an in-place algorithm is an algorithm which transforms input using no auxiliary data structure. However a small amount of extra storage space is allowed for auxiliary variables. The input is usually overwritten by the output as the algorithm executes. In-place algorithm updates input sequence only through replacement or swapping of elements. An algorithm which is not in-place is sometimes called not-in-place or out-of-place.

So basically our old array will be overwritten! This is important if you want to keep the old array for other reasons. So keep this in mind.

Sorting algorithm

Stable sort algorithms sort identical elements in the same order that they appear in the input. When sorting some kinds of data, only part of the data is examined when determining the sort order. For example, in the card sorting example to the right, the cards are being sorted by their rank, and their suit is being ignored. This allows the possibility of multiple different correctly sorted versions of the original list. Stable sorting algorithms choose one of these, according to the following rule: if two items compare as equal, like the two 5 cards, then their relative order will be preserved, so that if one came before the other in the input, it will also come before the other in the output.

enter image description here

An example of stable sort on playing cards. When the cards are sorted by rank with a stable sort, the two 5s must remain in the same order in the sorted output that they were originally in. When they are sorted with a non-stable sort, the 5s may end up in the opposite order in the sorted output.

This shows that the sorting is right but it changed. So in the real world even if the sorting is correct we have to make sure that we get what we expect! This is super important keep this in mind as well. For more JavaScript examples look into the Array.prototype.sort() - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

@Gavin 2018-10-12 18:57:47

You flippin rock, thank you for this incredible answer. One of the best I've seen on SO. Cheers.

@momomo 2019-01-27 18:59:57

If only you could provide a freaking method to use at the end. Great answer though!

@Megajin 2019-02-22 07:25:29

@momomo the problem is, depending on what you expect from sorting, there is no right method. However you can simply use this piece of code from my answer: Object.keys(testObj).sort().reduce((a, c) => (a[c] = testObj[c], a), {}).

@metakungfu 2019-07-16 21:32:00

The one line:

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

@Wildhammer 2019-07-15 13:41:51

Object.keys(unordered).sort().reduce(
    (acc,curr) => ({...acc, [curr]:unordered[curr]})
    , {}
)

@Mathias Bynens 2015-06-28 17:23:41

The other answers to this question are outdated, never matched implementation reality, and have officially become incorrect now that the ES6/ES2015 spec has been published.


See the section on property iteration order in Exploring ES6 by Axel Rauschmayer:

All methods that iterate over property keys do so in the same order:

  1. First all Array indices, sorted numerically.
  2. Then all string keys (that are not indices), in the order in which they were created.
  3. Then all symbols, in the order in which they were created.

So yes, JavaScript objects are in fact ordered, and the order of their keys/properties can be changed.

Here’s how you can sort an object by its keys/properties, alphabetically:

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"}'

Use var instead of const for compatibility with ES5 engines.

@Phil 2015-09-22 14:44:05

I really cant see a difference to your code and the top answer here apart from using a slightly different looping technique. Whether or not the objects can be said to be "ordered" or not seems to be irrelevant. The answer to this question is still the same. The published spec merely confirms the answers here.

@Felix Kling 2015-12-01 14:41:53

FYI, it was clarified that the enumeration order of properties is still undefined: esdiscuss.org/topic/…

@cchamberlain 2016-03-14 05:25:28

@Phil_1984_ This answer and top voted answer are very different. OP's question was how to sort an object literal. Top voted answer says you can't, then gives a workaround by storing sorted keys in an array, then iterating and printing key value pairs from the sorted array. This answer claims that the order of object literals are now sortable and his example stores the sorted key values back to an object literal, then prints the sorted object directly. On a side note, it would be nice if the linked site still existed.

@Phil 2016-03-14 16:25:24

Both answers simply use the Array.sort function to sort the keys first. The OP is asking to sort a "JavaScript object" and is merely using JavaScript Object Notation (JSON) to describe the 2 objects. These 2 objects are logically identical meaning sorting is irrelevant. I think the top answer explains this a lot better. Saying "all other answers are now officially incorrect" is too extreme for me, especially with a broken link. I think the problem is "this new ES6 spec" is giving the illusion that Javascript objects have an ordered list of keys which is simply not true.

@Manuel Arwed Schmidt 2016-05-02 12:00:29

Please add that this solution is not supported by a variety of modern browsers (google "caniuse ES6"). Using this answers risks hard-to-find bugs in certain browsers only (e.g. Safari when Chrome is all fine).

@Mathias Bynens 2016-05-03 09:36:38

@ManuelArwedSchmidt Browser support for ES6 is not binary — ES6 is not just a single feature. Can you name one modern browser in which the above does not work?

@Fagner Brack 2016-06-13 13:20:32

Broken link, does anybody have a working one?

@Mathias Bynens 2016-06-13 14:24:50

@FagnerBrack The new link is exploringjs.com/es6/… but the contents have changed.

@Fagner Brack 2016-06-14 12:14:34

@MathiasBynens That's unfortunate =/. Maybe edit the answer removing the link and stating that the contents of the original link has changed?

@Robert Broden 2016-11-21 20:44:37

i am working with SOAP server and using Nodejs strong-soap as a SOAP client. The object gets parsed into a SOAP message and the SOAP server wants it in alphabetical order. A solution like this is necessary in order for submission. Thanks a lot!

@Amresh Venugopal 2017-02-08 10:19:10

link is broken?

@thdoan 2018-04-22 10:28:06

Surprisingly, the chrome.storage API still sorts object keys in lexicographic order, which is not even consistent with Chrome V8.

@Shivam Sharma 2018-12-10 12:20:41

What to do If I need them in reverse order? Below code is not working: Object.keys(RES).sort(function(a,b){return b-a;}).forEach(function(key) {RES1[key] = RES[key];}); Neither: Object.keys(P).sort().reverse().forEach(function(key) {P1[key] = P[key];}); is working.

@Christopher King 2019-01-13 08:09:56

The link says that "Own Property Keys" are ordered but that "Enumerable Own Names" are not and the latter controls for JSON: "The order is not defined by ES6, but it must be the same order in which for-in traverses properties. Used by: JSON.parse(), JSON.stringify(), Object.keys()" So the documentation referenced explicitly says that JSON uses a undefined ordering! Yet the example provided works everywhere I tired... but I'd still like to know if that's by happenstance or because it's specified that way.

@sravan kumar ganji 2018-04-04 22:57:28

here is the 1 liner

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), {} ));

@Ron Daulagupu 2018-08-10 07:18:26

totally works. should be the accepted answer.

@ntaso 2019-07-09 09:37:26

What the heck is this crazy syntax? (o[k] = v, o). Why does this even work, where can I find docs about it? It obviously returns the rightmost parameter, but why?

@James 2019-07-11 20:51:46

@ntaso here

@Tahsin Turkoz 2019-08-06 23:34:43

short function first makes o[k] equals to v and then returns o

@Ben 2019-03-17 15:48:29

It's 2019 and we have a 2019 way to solve this :)

Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())

@a2441918 2019-05-09 16:47:29

How do we sort nested objects by key?

@user2912903 2019-10-21 09:56:52

@a2441918 In the same way as you would do with the sort() function. Have a look: developer.mozilla.org/de/docs/Web/JavaScript/Reference/… Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort((k, j) => k - j))

@momomo 2019-01-27 19:11:39

Not sure if this answers the question, but this is what I needed.

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

Called as :

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

@Matt Ball 2011-03-29 02:11:52

JavaScript objects1 are not ordered. It is meaningless to try to "sort" them. If you want to iterate over an object's properties, you can sort the keys and then retrieve the associated values:

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


Alternate implementation using Object.keys fanciness:

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


1Not to be pedantic, but there's no such thing as a JSON object.

@Michael J. Calkins 2013-03-26 02:47:31

Excellent answer here's my own implementation in a real world situation: gist.github.com/clouddueling/5242726

@Paul 2013-07-12 20:02:29

@MarcelKorpel There is such thing as a JSON object. Check section 8 of the official JSON RFC: ietf.org/rfc/rfc4627.txt

@Matt Ball 2013-07-12 20:33:00

@Paulpro two things to note about that RFC: first, it's 7 years old at this point, and vocabulary changes over time; second, "This memo provides information for the Internet community. It does not specify an Internet standard of any kind." Whether a given sequence of characters represents a JavaScript object literal or a JSON text depends on context/usage. The term "JSON object" conflates and makes the distinction ambiguous in a detrimental way. Let's be rid of the imprecise terminology, and use the more precise term where possible. I see no reason to do otherwise. Words matter.

@Matt Ball 2013-07-12 20:34:52

@Paul 2013-07-12 20:48:37

@MattBall IMO JSON Object is a very precise term for a string like {"a", 1} just as JSON Array is precise term for a string like [1]. It is useful to be able to communicate by saying things like the third object in my array when you have the string [{x: 1}, {y: 2}, {z: 3}], so I much prefer "That is not a JSON object" when commenting about a Javascript literal, rather then "There is no such thing as a JSON object", which is just going to cause more confusion and communication difficulties later when the OP actually is working with JSON.

@Matt Ball 2013-07-12 21:01:30

@Paulpro I must disagree. {"a", 1} is either an object literal or a JSON text (aka JSON string, if you really prefer). Which it is depends on context, the former if it appears verbatim within JavaScript source code, the latter if it's a string that needs to be passed to a JSON parser to be used further. There are real differences between the two when it comes to allowed syntax, correct usage, and serialization.

@Paul 2013-07-12 21:14:54

@MattBall I am referring to it in a string context of course, and yes it is a JSON text, but [{x: 1}, {y: 2}, {z: 3}] is also a JSON text which consists of 3 JSON objects in a JSON array.

@Matt Ball 2013-07-12 21:31:11

@Paulpro but that's not valid JSON! It's a valid JavaScript literal, however. If it were valid JSON, I describe it as a JSON text comprised of an array whose elements are 3 objects. The thing you describe, in my mind, would be something like this: '["{\"x\": 1}", "{\"y\": 2}", "{\"z\": 3}"]'. Re-identifying the inner objects as JSON implies that they should be parsed by a JSON parser. Remember that JSON is a text format. You say "a string context of course" but that's not obvious when you write something like [{"x": 1}, {"y": 2}, {"z": 3}]. It could be JSON,

@Matt Ball 2013-07-12 21:34:07

or it could be an array literal, but it depends on context. We use terminology to disambiguate. Do you disagree that the terminology I'm advocating is less ambiguous than "JSON object?"

@Paul 2013-07-12 21:41:21

@MattBall I guess I see JSON Object as an unambiguous term (that is usually used incorrectly) for a substring of JSON that begins with a { character and ends with a } character. I wish that people would say JSON Object when that is exactly what they mean, not when they are referring to a Javascript object literal, nor a JSON text that begins with [.

@Matt Ball 2013-07-12 21:47:37

@Paulpro right. The problem is that people do misuse it when they really mean a (JavaScript) object literal.

@Mathias Bynens 2015-06-28 17:24:35

Now that ES6/ES2015 is finalized, this answer has officially become incorrect. See my answer for more info.

@Matt Ball 2015-10-15 23:58:04

@Iscariot what do you mean by "does not work?" Keys are always strings, never numbers.

@eriksssss 2016-10-23 19:57:49

One reason that sorting JSON data is helpful: Comparing 2 data files for differences. Yes you can do so programmatically, but JSON is a text format which sometimes needs to compared quickly and visually.

@momomo 2019-01-27 19:01:20

if only people could learn to provide a ready to use function when already putting all this time into an answer.

@Joeri 2019-06-15 11:32:55

I see the syntax nazis are still not dead. It would be nice to be able to write/print JSON to disk or console in human readable order. That's how I understand the question. Chrome now does this by default. ibb.co/G7hyr2S

@brunettdan 2018-07-23 15:33:36

Sorts keys recursively while preserving references.

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

Example:

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}

@Boyang 2018-10-19 04:11:52

Nice snippet! What's the purpose of delete o[e[0]]; there? Can't we just assign?

@brunettdan 2018-10-20 08:51:34

It seems like only new assignments to non existent keys will append the key at the end. If delete is commented out, keys wont be sorted, at least not in Chrome.

@Boyang 2018-10-23 09:21:48

that makes sense. Thanks! In any case, this is sort of a lost cause because js object keys have no sequence, according to the specs. We are just exploiting obj and log function impl details

@brunettdan 2018-10-24 11:21:09

Yea, I use the Map when order of keys are important: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

@Dmitry Sheiko 2015-07-30 13:38:18

Maybe a bit more elegant form:

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

P.S. and the same with ES6+ syntax:

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

@momomo 2019-01-27 18:58:33

it's sorts nothing. you still returning an object. you cannot gurantee the objects in your target is actually going to have any order. you need to return an array. jeeezus.

@momomo 2019-01-27 18:59:17

the only thing you are doing here is ensuring it's a set, in a non optimal way.

@user3286817 2017-08-26 16:38:51

recursive sort, for nested object and arrays

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!'
            }
        },
    ]
});

@jononomo 2018-04-26 06:44:24

I think you need an else in there -- could be true for both Array.isArray(obj[key]) and for typeof obj[key] === 'object'

@isgoed 2019-02-26 14:16:22

When you have an array of primitives, your function transforms the primitives (string/number) to empty objects. To catch this I added the following right at the beginning of your function: function sortObjectKeys(obj){: if(typeof obj != 'object'){ /* it is a primitive: number/string (in an array) */ return obj; }. For robustness I at the complete start also added: if(obj == null || obj == undefined){ return obj; }

@user3286817 2017-08-26 16:24:25

function sortObjectKeys(obj){
    return Object.keys(obj).sort().reduce((acc,key)=>{
        acc[key]=obj[key];
        return acc;
    },{});
}

sortObjectKeys({
    telephone: '069911234124',
    name: 'Lola',
    access: true,
});

@aristotll 2017-08-26 16:57:53

Maybe adding some explanation of your code is better.

@user3286817 2017-08-29 05:32:19

Gets the keys of the object, so it is array of strings, I sort() them and as it is array of strings (keys) I reduce them (with reduce() of js Array). The acc initially is an empty object {} (last arg of reducer) and the reducer (callback) assigns on the empty object the values of the source obj with the ordered key sequence.

@João Pimentel Ferreira 2017-06-03 12:17:06

Just to simplify it and make it more clear the answer from 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]);
}

@codename- 2015-04-14 08:33:40

A lot of people have mention that "objects cannot be sorted", but after that they are giving you a solution which works. Paradox, isn't it?

No one mention why those solutions are working. They are, because in most of the browser's implementations values in objects are stored in the order in which they were added. That's why if you create new object from sorted list of keys it's returning an expected result.

And I think that we could add one more solution – ES5 functional way:

function sortObject(obj) {
    return Object.keys(obj).sort().reduce(function (result, key) {
        result[key] = obj[key];
        return result;
    }, {});
}

ES2015 version of above (formatted to "one-liner"):

function sortObject(o) {
    return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {});
}

Short explanation of above examples (as asked in comments):

Object.keys is giving us a list of keys in provided object (obj or o), then we're sorting those using default sorting algorithm, next .reduce is used to convert that array back into an object, but this time with all of the keys sorted.

@Mathias Bynens 2015-06-28 17:26:07

@Pointy This behavior has always available in all major browsers, and has been standardized in ES6/ES2015. I’d say this is good advice.

@Steven de Salas 2015-07-12 12:55:52

This is the simplest and most concise way of accomplishing task in EcmaScript v5. A bit late to the party but should be the accepted answer.

@Felix Kling 2016-02-18 16:17:40

"They are, because in most of the browser's implementations values in objects are stored in the order in which they were added" Only for non-numerical properties though. Also note that there is still no guarantee in which order the properties are iterated over (e.g. via for...in).

@cchamberlain 2016-03-14 05:29:47

True one liner: const sortObject = o => Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})

@ola 2017-04-02 17:06:55

Nice of you to explain why it's working it did the lesson for me. Thanks!

@aks. 2017-06-22 22:48:18

My linter complained about that one-liner (returning an assignment), but this one works for me and is easier for me to read: Object.keys(dict).sort().reduce((r, k) => Object.assign(r, { [k]: dict[k] }), {});

@fernandopasik 2017-04-06 23:22:04

There's a great project by @sindresorhus called sort-keys that works awesome.

You can check its source code here:

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

Or you can use it with npm:

$ npm install --save sort-keys

Here are also code examples from his 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}

@Narayanaperumal Gurusamy 2017-01-10 19:23:00

Just use lodash to unzip map and sortBy first value of pair and zip again it will return sorted key.

If you want sortby value change pair index to 1 instead of 0

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

enter image description here

@Jed Fox 2017-01-10 23:40:42

Please use the edit link explain how this code works and don't just give the code, as an explanation is more likely to help future readers. See also How to Answer. source

@JLavoie 2015-07-14 03:16:31

Simple and readable snippet, using lodash.

You need to put the key in quotes only when calling sortBy. It doesn't have to be in quotes in the data itself.

_.sortBy(myObj, "key")

Also, your second parameter to map is wrong. It should be a function, but using pluck is easier.

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

@BlueRaja - Danny Pflughoeft 2016-11-10 17:42:58

Here is a clean lodash-based version that works with nested objects

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

It would be even cleaner if lodash had a toObject() method...

@Case 2015-10-15 23:35:26

Pure JavaScript answer to sort an Object. This is the only answer that I know of that will handle negative numbers. This function is for sorting numerical Objects.

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

The output will be an object sorted by those numbers with new keys starting at 0.

@Sergio Moura 2015-10-14 11:47:36

This is an old question, but taking the cue from Mathias Bynens' answer, I've made a short version to sort the current object, without much overhead.

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

after the code execution, the "unordered" object itself will have the keys alphabetically sorted.

@Sherali Turdiyev 2015-08-27 09:19:31

I transfered some Java enums to javascript objects.

These objects returned correct arrays for me. if object keys are mixed type (string, int, char), there is a problem.

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

@Benny Neugebauer 2015-07-06 21:55:53

Solution:

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

Explanation:

Many JavaScript runtimes store values inside an object in the order in which they are added.

To sort the properties of an object by their keys you can make use of the Object.keys function which will return an array of keys. The array of keys can then be sorted by the Array.prototype.sort() method which sorts the elements of an array in place (no need to assign them to a new variable).

Once the keys are sorted you can start using them one-by-one to access the contents of the old object to fill a new object (which is now sorted).

Below is an example of the procedure (you can test it in your targeted browsers):

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

Note: Object.keys is an ECMAScript 5.1 method but here is a polyfill for older browsers:

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

@Flavien Volken 2015-06-07 13:08:50

Underscore version:

function order(unordered)
{
return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]}));
}

If you don't trust your browser for keeping the order of the keys, I strongly suggest to rely on a ordered array of key-value paired arrays.

_.sortBy(_.pairs(c),function(o){return o[0]})

@Afanasii Kurakin 2019-04-24 08:33:43

Better: _.object(_.sortBy(_.pairs(unordered), _.first))

@Steven Keith 2014-10-29 16:32:51

As already mentioned, objects are unordered.

However...

You may find this idiom useful:

var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };

var kv = [];

for (var k in o) {
  kv.push([k, o[k]]);
}

kv.sort()

You can then iterate through kv and do whatever you wish.

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

@Mathias Bynens 2015-06-28 17:26:41

@Phani Reddy 2014-02-25 14:30:45

Use this code if you have nested objects or if you have nested array 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;
};

@rusmus 2014-02-25 14:53:06

The author doesn't state say that he is using jQuery, nor is the question tagged jQuery. It would be nice if you addes a solution in pure javascript.

@Will Sheppard 2016-03-18 14:47:10

Thanks @Phani this is exactly what I needed

@Serg 2013-08-06 20:35:52

Suppose it could be useful in VisualStudio debugger which shows unordered object properties.

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

@Mugiwara 2014-01-01 20:43:58

So Great Thanks a loooot

@Con Antonakos 2015-11-05 16:28:55

Nice! Thank you for this succinct solution.

@Brian M. Hunt 2013-06-23 13:54:06

Using lodash this will work:

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

Just food for thought.

@Ashit Vora 2012-10-11 07:34:56

This works for me

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

@radicand 2013-04-26 10:30:58

This is actually the correct answer to the question at hand. For a simplified version using Underscore, see: jsfiddle.net/wPjaQ/1

@Paul 2013-07-12 21:50:40

@radicand No this answer is not correct. It returns a new object, which also has no order.

@radicand 2013-07-15 15:35:13

@Paulpro in theory it doesn't, in practice it does.

@Paul 2013-07-15 15:39:58

@radicand It doesn't in practice either. There is no such thing as order on an objects keys, so how can you say that in practice this gives you an object in sorted order? It really just gives you back a shallow copy of the object you pass in.

@radicand 2013-07-15 15:40:48

@Paulpro, did you look at the jsfiddle?

@Paul 2013-07-15 15:44:40

@radicand Yes, I see the same object twice.

@Yobert 2014-10-01 06:06:29

This is super wrong. It might happen to work for now, but will break in a different web browser or different page load in the same browser. Browsers may randomize object keys for security, or as you fill up an object, it will put the values into different memory buckets depending on the keys, which will return a different order. If this happens to work it's just lucky for you.

@RobG 2014-12-01 07:17:27

It also has a needless use of jQuery.

@TachyonVortex 2015-04-10 10:10:38

As @Yobert says, this answer is wrong. It might happen to work in some browsers, but it's never guaranteed. JavaScript object properties are never guaranteed to be ordered. From ECMAScript 5.1 §12.6.4: "The mechanics and order of enumerating the properties is not specified." For more details, see this question: Does JavaScript Guarantee Object Property Order?

Related Questions

Sponsored Content

34 Answered Questions

[SOLVED] How do I sort a dictionary by value?

65 Answered Questions

[SOLVED] How do I correctly clone a JavaScript object?

41 Answered Questions

[SOLVED] Loop through an array in JavaScript

27 Answered Questions

[SOLVED] What does "use strict" do in JavaScript, and what is the reasoning behind it?

41 Answered Questions

[SOLVED] How do I remove a property from a JavaScript object?

43 Answered Questions

[SOLVED] Sort array of objects by string property value

69 Answered Questions

[SOLVED] What is the most efficient way to deep clone an object in JavaScript?

47 Answered Questions

38 Answered Questions

[SOLVED] How do I loop through or enumerate a JavaScript object?

20 Answered Questions

[SOLVED] Checking if a key exists in a JavaScript object?

  • 2009-07-08 13:21:32
  • Adam Ernst
  • 1822311 View
  • 2760 Score
  • 20 Answer
  • Tags:   javascript object

Sponsored Content