Question

# [Solved] How to sort a map by value in JavaScript?

How to sort this map by value?

``````var map = new Map();
map.set('orange', 10);
map.set('apple', 5);
map.set('banana', 20);
map.set('cherry', 13);
``````

## Solution #1:

Yo could take a different approach and change `Symbol.iterator` of `Map.prototype[@@iterator]()` for a custom sorted result.

``````var map = new Map();

map.set("orange", 10);
map.set("apple", 5);
map.set("banana", 20);
map.set("cherry", 13);

map[Symbol.iterator] = function* () {
yield* [...this.entries()].sort((a, b) => a - b);
}

for (let [key, value] of map) {     // get data sorted
console.log(key + ' ' + value);
}

console.log([...map]);              // sorted order
console.log([...map.entries()]);    // original insertation order``````
``.as-console-wrapper { max-height: 100% !important; top: 0; }``

## Solution #2:

``````const myMap = new Map();
myMap.set("a",3);
myMap.set("c",4);
myMap.set("b",1);
myMap.set("d",2);

// sort by value
const mapSort1 = new Map([...myMap.entries()].sort((a, b) => b - a));
console.log(mapSort1);
// Map(4) {"c" => 4, "a" => 3, "d" => 2, "b" => 1}

const mapSort2 = new Map([...myMap.entries()].sort((a, b) => a - b));
console.log(mapSort2);
// Map(4) {"b" => 1, "d" => 2, "a" => 3, "c" => 4}

// sort by key
const mapSort3 = new Map([...myMap.entries()].sort());
console.log(mapSort3);
// Map(4) {"a" => 3, "b" => 1, "c" => 4, "d" => 2}

const mapSort4 = new Map([...myMap.entries()].reverse());
console.log(mapSort4);
// Map(4) {"d" => 2, "b" => 1, "c" => 4, "a" => 3}
``````

## Solution #3:

In ES6 you can do it like this: (assume your Map object is `m`).

``````[...m].map(e =>{ return e;}).slice().sort(function(a, b) {
return a - b;
});
``````

the spread operator turns a Map object into an array, then takes out the second element of each subarray to build a new array, then sort it. If you want to sort in descending order just replace `a - b` with `b - a`.

## Solution #4:

You can shorten the function and use this in ES6- using arrow function (lambda)

`````` let m2= new Map([...m.entries()].sort((a,b) => b - a))
``````

## Solution #5:

You can use list maps instead of map only.
Try this:

``````var yourListMaps = [];
var a = {quantity: 10, otherAttr: 'tmp1'};
var b = {quantity: 20, otherAttr: 'tmp2'};
var c = {quantity: 30, otherAttr: 'tmp3'};
yourListMaps.push(a);
yourListMaps.push(b);
yourListMaps.push(c);
``````

And if you want to sort by quantity, you can:

``````// Sort c > b > a
yourListMaps.sort(function(a,b){
return b.quantity - a.quantity;
});
``````

or

``````// Sort a > b > c
yourListMaps.sort(function(a,b){
return a.quantity - b.quantity;
});
``````

## Solution #6:

There are several valid answers here but I think the “ordered map” aspect complicates and confuses things unnecessarily.

Assuming it is sufficient to get a list of the keys in the map sorted by value, rather than a map whose entries are sorted by value, then something like this works:

``````var map = {
orange: 10,
apple: 5,
banana: 20,
cherry: 13
}

var sorted_keys = Object.keys(map).sort(function(a,b) { return map[a] - map[b]; });
``````

which yields:

``````["apple", "orange", "cherry", "banana"]
``````

This is a little less elegant if you actually want to iterate over the map entries (now you need to iterate over the array of sorted keys and fetch the values instead) but:

1. This logic is much easier for my simple mind to follow and to remember.

2. There’s a pretty common use case for “sort this map by value” in which you actually want the sorted list of keys: using a map to keep a tally. (E.g., iterating over the words in a file using a map to keep try of how often each word appears then sorting that map to get a list of words by frequency.)

For the general case in which the values in the map aren’t necessarily numeric, replace the comparator function (the function passed to `Object.keys(map).sort`) with something like:

``````function(a, b) {
return (a < b) ? -1 : ( (a > b) ? 1 : 0 );
}
``````

(which is essentially:

``````function(a, b) {
if (a < b) {
return -1;
} else if (a > b) {
return 1;
} else {
return 0;
}
}
``````

but using the ternary (`? :`) operator.)

But bear in mind that the behavior of JavaScript’s `<` and `>` operators is sometimes a little counter-intuitive with mixed types so depending on the values in your map you may want to include explicit type-casting logic in your comparator.

## Solution #7:

To Sort Object simply use

``````const sortedObject = mapObject.sort((a,b)=>return b.value - a.value)
``````

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .
To Top
India and Pakistan’s steroid-soaked rhetoric over Kashmir will come back to haunt them both clenbuterol australia bossier man pleads guilty for leadership role in anabolic steriod distribution conspiracy