# How to sort an array of objects by multiple fields?

## How to sort an array of objects by multiple fields?

From this original question, how would I apply a sort on multiple fields?
Using this slightly adapted structure, how would I sort city (ascending) & then price (descending)?
var homes = [
{“h_id”:”3″,
“city”:”Dallas”,
“state”:”TX”,
“zip”:”75201″,
“price”:”162500″},
{“h_id”:”4″,
“city”:”Bevery Hills”,
“state”:”CA”,
“zip”:”90210″,
“price”:”319250″},
{“h_id”:”6″,
“city”:”Dallas”,
“state”:”TX”,
“zip”:”75000″,
“price”:”556699″},
{“h_id”:”5″,
“city”:”New York”,
“state”:”NY”,
“zip”:”00010″,
“price”:”962500″}
];

I liked the fact than an answer was given which provided a general approach. Where I plan to use this code, I will have to sort dates as well as other things. The ability to “prime” the object seemed handy, if not a little cumbersome.
I’ve tried to build this answer into a nice generic example, but I’m not having much luck.

### Solution 1:

A multi dimensional sorting method, based on this answer:

Update: Here is an “optimized” version. It does a lot more preprocessing and creates a comparison function for each sorting option beforehand. It might need more more memory (as it stores a function for each sorting option, but it should preform a bit better as it does not have to determine the correct settings during the comparison. I have not done any profiling though.

``````var sort_by;

(function() {
// utility functions
var default_cmp = function(a, b) {
if (a == b) return 0;
return a < b ? -1 : 1;
},
getCmpFunc = function(primer, reverse) {
var dfc = default_cmp, // closer in scope
cmp = default_cmp;
if (primer) {
cmp = function(a, b) {
return dfc(primer(a), primer(b));
};
}
if (reverse) {
return function(a, b) {
return -1 * cmp(a, b);
};
}
return cmp;
};

// actual implementation
sort_by = function() {
var fields = [],
n_fields = arguments.length,
field, name, reverse, cmp;

// preprocess sorting options
for (var i = 0; i < n_fields; i++) {
field = arguments[i];
if (typeof field === 'string') {
name = field;
cmp = default_cmp;
}
else {
name = field.name;
cmp = getCmpFunc(field.primer, field.reverse);
}
fields.push({
name: name,
cmp: cmp
});
}

// final comparison function
return function(A, B) {
var a, b, name, result;
for (var i = 0; i < n_fields; i++) {
result = 0;
field = fields[i];
name = field.name;

result = field.cmp(A[name], B[name]);
if (result !== 0) break;
}
return result;
}
}
}());
``````

Example usage:

``````homes.sort(sort_by('city', {name:'price', primer: parseInt, reverse: true}));
``````

DEMO

Original function:

``````var sort_by = function() {
var fields = [].slice.call(arguments),
n_fields = fields.length;

return function(A,B) {
var a, b, field, key, primer, reverse, result, i;

for(i = 0; i < n_fields; i++) {
result = 0;
field = fields[i];

key = typeof field === 'string' ? field : field.name;

a = A[key];
b = B[key];

if (typeof field.primer  !== 'undefined'){
a = field.primer(a);
b = field.primer(b);
}

reverse = (field.reverse) ? -1 : 1;

if (a<b) result = reverse * -1;
if (a>b) result = reverse * 1;
if(result !== 0) break;
}
return result;
}
};
``````

DEMO

### Solution 2:

for a non-generic, simple solution to your exact problem:

``````homes.sort(
function(a, b) {
if (a.city === b.city) {
// Price is only important when cities are the same
return b.price - a.price;
}
return a.city > b.city ? 1 : -1;
});
``````

### Solution 3:

Here is a simple functional approach. Specify sort order using array. Prepend minus to specify descending order.

``````var homes = [
{"h_id":"3", "city":"Dallas", "state":"TX","zip":"75201","price":"162500"},
{"h_id":"4","city":"Bevery Hills", "state":"CA", "zip":"90210", "price":"319250"},
{"h_id":"6", "city":"Dallas", "state":"TX", "zip":"75000", "price":"556699"},
{"h_id":"5", "city":"New York", "state":"NY", "zip":"00010", "price":"962500"}
];

homes.sort(fieldSorter(['city', '-price']));
// homes.sort(fieldSorter(['zip', '-state', 'price'])); // alternative

function fieldSorter(fields) {
return function (a, b) {
return fields
.map(function (o) {
var dir = 1;
if (o[0] === '-') {
dir = -1;
o=o.substring(1);
}
if (a[o] > b[o]) return dir;
if (a[o] < b[o]) return -(dir);
return 0;
})
.reduce(function firstNonZeroValue (p,n) {
return p ? p : n;
}, 0);
};
}
``````

Edit: in ES6 it’s even shorter!

``````"use strict";
const fieldSorter = (fields) => (a, b) => fields.map(o => {
let dir = 1;
if (o[0] === '-') { dir = -1; o=o.substring(1); }
return a[o] > b[o] ? dir : a[o] < b[o] ? -(dir) : 0;
}).reduce((p, n) => p ? p : n, 0);

const homes = [{"h_id":"3", "city":"Dallas", "state":"TX","zip":"75201","price":162500},     {"h_id":"4","city":"Bevery Hills", "state":"CA", "zip":"90210", "price":319250},{"h_id":"6", "city":"Dallas", "state":"TX", "zip":"75000", "price":556699},{"h_id":"5", "city":"New York", "state":"NY", "zip":"00010", "price":962500}];
const sortedHomes = homes.sort(fieldSorter(['state', '-price']));

document.write('<pre>' + JSON.stringify(sortedHomes, null, '\t') + '</pre>')``````

### Solution 4:

I made a quite generic multi feature sorter today. You can have a look at thenBy.js here: https://github.com/Teun/thenBy.js

It allows you to use the standard Array.sort, but with firstBy().thenBy().thenBy() style. It is way less code and complexity than the solutions posted above.

### Solution 5:

The following function will allow you to sort an array of objects on one or multiple properties, either ascending (default) or descending on each property, and allow you to choose whether or not to perform case sensitive comparisons. By default, this function performs case insensitive sorts.

The first argument must be the array containing the objects.
The subsequent argument(s) must be a comma separated list of strings that reference the different object properties to sort by. The last argument (which is optional) is a boolean to choose whether or not to perform case sensitive sorts – use `true` for case sensitive sorts.

The function will sort each property/key in ascending order by default. If you want a particular key to sort in descending order, then instead pass in an array in this format: `['property_name', true]`.

Here are some sample uses of the function followed by an explanation (where `homes` is an array containing the objects):

`objSort(homes, 'city')` –> sort by city (ascending, case in-sensitive)

`objSort(homes, ['city', true])` –> sort by city (descending, case in-sensitive)

`objSort(homes, 'city', true)` –> sort by city then price (ascending, case sensitive)

`objSort(homes, 'city', 'price')` –> sort by city then price (both ascending, case in-sensitive)

`objSort(homes, 'city', ['price', true])` –> sort by city (ascending) then price (descending), case in-sensitive)

And without further ado, here’s the function:

``````function objSort() {
var args = arguments,
array = args[0],
case_sensitive, keys_length, key, desc, a, b, i;

if (typeof arguments[arguments.length - 1] === 'boolean') {
case_sensitive = arguments[arguments.length - 1];
keys_length = arguments.length - 1;
} else {
case_sensitive = false;
keys_length = arguments.length;
}

return array.sort(function (obj1, obj2) {
for (i = 1; i < keys_length; i++) {
key = args[i];
if (typeof key !== 'string') {
desc = key[1];
key = key[0];
a = obj1[args[i][0]];
b = obj2[args[i][0]];
} else {
desc = false;
a = obj1[args[i]];
b = obj2[args[i]];
}

if (case_sensitive === false && typeof a === 'string') {
a = a.toLowerCase();
b = b.toLowerCase();
}

if (! desc) {
if (a < b) return -1;
if (a > b) return 1;
} else {
if (a > b) return -1;
if (a < b) return 1;
}
}
return 0;
});
} //end of objSort() function
``````

And here’s some sample data:

``````var homes = [{
"h_id": "3",
"city": "Dallas",
"state": "TX",
"zip": "75201",
"price": 162500
}, {
"h_id": "4",
"city": "Bevery Hills",
"state": "CA",
"zip": "90210",
"price": 1000000
}, {
"h_id": "5",
"city": "new york",
"state": "NY",
"zip": "00010",
"price": 1000000
}, {
"h_id": "6",
"city": "Dallas",
"state": "TX",
"zip": "85000",
"price": 300000
}, {
"h_id": "7",
"city": "New York",
"state": "NY",
"zip": "00020",
"price": 345000
}];
``````

### Solution 6:

Here’s another one that’s perhaps closer to your idea for the syntax

``````function sortObjects(objArray, properties /*, primers*/) {
var primers = arguments[2] || {}; // primers are optional

properties = properties.map(function(prop) {
if( !(prop instanceof Array) ) {
prop = [prop, 'asc']
}
if( prop[1].toLowerCase() == 'desc' ) {
prop[1] = -1;
} else {
prop[1] = 1;
}
return prop;
});

function valueCmp(x, y) {
return x > y ? 1 : x < y ? -1 : 0;
}

function arrayCmp(a, b) {
var arr1 = [], arr2 = [];
properties.forEach(function(prop) {
var aValue = a[prop[0]],
bValue = b[prop[0]];
if( typeof primers[prop[0]] != 'undefined' ) {
aValue = primers[prop[0]](aValue);
bValue = primers[prop[0]](bValue);
}
arr1.push( prop[1] * valueCmp(aValue, bValue) );
arr2.push( prop[1] * valueCmp(bValue, aValue) );
});
return arr1 < arr2 ? -1 : 1;
}

objArray.sort(function(a, b) {
return arrayCmp(a, b);
});
}

// just for fun use this to reverse the city name when sorting
function demoPrimer(str) {
return str.split('').reverse().join('');
}

// Example
sortObjects(homes, ['city', ['price', 'desc']], {city: demoPrimer});
``````

Edit: Just for fun, here’s a variation that just takes an sql-like string, so you can do `sortObjects(homes, "city, price desc")`

``````function sortObjects(objArray, properties /*, primers*/) {
var primers = arguments[2] || {};

properties = properties.split(/\s*,\s*/).map(function(prop) {
prop = prop.match(/^([^\s]+)(\s*desc)?/i);
if( prop[2] && prop[2].toLowerCase() === 'desc' ) {
return [prop[1] , -1];
} else {
return [prop[1] , 1];
}
});

function valueCmp(x, y) {
return x > y ? 1 : x < y ? -1 : 0;
}

function arrayCmp(a, b) {
var arr1 = [], arr2 = [];
properties.forEach(function(prop) {
var aValue = a[prop[0]],
bValue = b[prop[0]];
if( typeof primers[prop[0]] != 'undefined' ) {
aValue = primers[prop[0]](aValue);
bValue = primers[prop[0]](bValue);
}
arr1.push( prop[1] * valueCmp(aValue, bValue) );
arr2.push( prop[1] * valueCmp(bValue, aValue) );
});
return arr1 < arr2 ? -1 : 1;
}

objArray.sort(function(a, b) {
return arrayCmp(a, b);
});
}
``````