How to sort an array of objects by multiple fields?

Question 1

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.

Question 2

Do you want to search or sort?

Question 3

What exactly is the issue you're having with using the second answer you've linked?

Question 4

It's not generic enough. I seem to be adding a sea of code when I simply would like to say sort(["first-field", "ASC"], ["second-field", "DSC"]); This is further complicated when I try to add in the "primer" logic of the first answer so that I can handle dates, case-insensitivity etc.

Question 5

You can check lodash.com/docs/4.17.11#orderBy , if you are ok using lodash

Question 6

The pattern for sorting by properties is homes.sort((a, b) =>...) with a.prop and b.prop. a.prop - b.prop sorts numerically, a.prop.localeCompare(b.prop) lexicographically, and (b.prop < a.prop) - (a.prop < b.prop) generically. To sort descending instead of ascending, negate the return value (e.g. b.prop - a.prop instead of a.prop - b.prop).

Question 7

You could use a chained sorting approach by taking the delta of values until it reaches a value not equal to zero.

var data = [{ 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" }];
data.sort(function (a, b) {
 return a.city.localeCompare(b.city) || b.price - a.price;
});
console.log(data);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Or, using es6, simply:

data.sort((a, b) => a.city.localeCompare(b.city) || b.price - a.price);

Question 8

what about if order by desc?

Question 9

@GarrodRan, switch a and b.

Question 10

This is a nice answer - very concise! Maybe worth explaining that it works because zero - as returned by localeCompare() when the two values match - is falsey, while -1 and +1 are truthy.

Question 11

This is a better solution than my proposal. Good, clean, and fun!

Question 12

If one of the field's is a number and you only want to sort by whether it's 0 or greater, then use (b.EstimatedItems > 0) - (a.EstimatedItems > 0) || a.Label.localeCompare(b.Label)). This will sort values with 0 to the bottom first and then sort by the string column.

Question 13

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

Question 14

I think this demo is what the OP wants => jsfiddle.net/zJ6UA/533

Question 15

@Snowburnt Your updated answer is incorrect for a different reason. The comparison function needs to return a negative value if value a would be ordered before b, 0 if they would be ordered equally, and a positive value if a would be ordered after b. Your function only returns false or true when comparing the cities, and never a negative value.

Question 16

You may use a.localeCompare(b) in the last line for the string compare... see the docs

Question 17

Shouldn't the first city comparison be checking for equality, not inequality? In other words, shouldn't the line be if (a.city === b.city)? That is, if the two cities are the same then compare the prices, otherwise compare the cities.

Question 18

very elegant. It would be nice if javascript has a sortBy and a following thenSortBy like LINQ.

Question 19

Here is a simple functional generic 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>')

Question 20

I found this function pretty neat so I made a small performance improvement of up to 90% depending on the parser. I made a gist and test suite.

Question 21

Based on the sample data it looks like numbers are sorted as expected, however when I tried implementing this numbers where sorting more like strings... [10,100,11,9]. Did I miss something?

Question 22

@MarkCarpenterJr. Not sure what you mean. my example sorts numeric types correctly. Can you share your implementation as a question and reference me in the comments so I see it? Then I can check.

Question 23

@MarkCarpenterJr. Just spotted it. I've added an explanation in the comments.

Question 24

I made a function inspired by this that uses the localeCompare pattern to support proper numeric sorting, I posted the answer here: stackoverflow.com/a/77205726/3799617

Question 25

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

Question 26

For the record, this function could still be improved by preprocessing the argument list and create a uniform "sort options array". This is left as exercise for the reader ;)

Question 27

@Mike: Ok... finally ;) You see it is more complex now, as the options are preprocessed, but the final comparison function (see comment) is much simpler which (hopefully) leads to better performance. The more sorting options you have, the more advantage you have from this method.

Question 28

To sort an array of objects by multiple fields:

homes.sort(function(left, right) {
 var city_order = left.city.localeCompare(right.city);
 var price_order = parseInt(left.price) - parseInt(right.price);
 return city_order || -price_order;
});

Notes

A function passed to array sort is expected to return negative/zero/positive to indicate less/equal/greater.
a.localeCompare(b) is universally supported for strings, and returns -1,0,1 if a<b,a==b,a>b.
Subtraction works on numeric fields, because a - b gives -,0,+ if a<b,a==b,a>b.
|| in the last line gives city priority over price.
Negate to reverse order in any field, as in -price_order
Add new fields to the or-chain: return city_order || -price_order || date_order;
Date compare with subtraction, because date math converts to milliseconds since 1970.
var date_order = new Date(left.date) - new Date(right.date); CAUTION: Date() returns a string, and is freakishly different from the new Date() constructor.
Boolean compare with subtraction, which is guaranteed to turn true and false to 1 and 0 (therefore the subtraction produces -1 or 0 or 1).
var goodness_order = Boolean(left.is_good) - Boolean(right.is_good)
Sorting on a boolean is unusual enough that I suggest drawing attention with the Boolean() constructor, even if they're already boolean.

Question 29

This is really nice. How do you compare booleans... err convert boolean comparisons to -1, 0, 1?

Question 30

This answer is amazing. A complete ordering master class. Thanks for the detailed explanation.

Question 31

Other answers are overly complicated. This one works great!

Question 32

This is a complete cheat but I think that it adds value to this question because it's basically a canned library function that you can use out-of-the box.

If your code has access to lodash or a lodash compatible library like underscore then you can use the _.sortBy method. The snippet below is copied directly from the lodash documentation.

The commented results in the examples looks like they return arrays of arrays but that's just showing the order and not the actual results which are an array of objects.

var users = [
 { 'user': 'fred',  'age': 48 },
 { 'user': 'barney', 'age': 36 },
 { 'user': 'fred',  'age': 40 },
 { 'user': 'barney', 'age': 34 }
];
_.sortBy(users, [function(o) { return o.user; }]);
 // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
_.sortBy(users, ['user', 'age']);
// => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]

Question 33

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

Question 34

A dynamic way to do that with MULTIPLE keys:

filter unique values from each col/key of sort
put in order or reverse it
add weights width zeropad for each object based on indexOf(value) keys values
sort using caclutated weights

enter image description here

Object.defineProperty(Array.prototype, 'orderBy', {
value: function(sorts) { 
 sorts.map(sort => { 
 sort.uniques = Array.from(
 new Set(this.map(obj => obj[sort.key]))
 );
 
 sort.uniques = sort.uniques.sort((a, b) => {
 if (typeof a == 'string') {
 return sort.inverse ? b.localeCompare(a) : a.localeCompare(b);
 }
 else if (typeof a == 'number') {
 return sort.inverse ? b - a : a - b;
 }
 else if (typeof a == 'boolean') {
 let x = sort.inverse ? (a === b) ? 0 : a? -1 : 1 : (a === b) ? 0 : a? 1 : -1;
 return x;
 }
 return 0;
 });
 });
 const weightOfObject = (obj) => {
 let weight = "";
 sorts.map(sort => {
 let zeropad = `${sort.uniques.length}`.length;
 weight += sort.uniques.indexOf(obj[sort.key]).toString().padStart(zeropad, '0');
 });
 //obj.weight = weight; // if you need to see weights
 return weight;
 }
 this.sort((a, b) => {
 return weightOfObject(a).localeCompare( weightOfObject(b) );
 });
 
 return this;
}
});

Use:

// works with string, number and boolean
let sortered = your_array.orderBy([
 {key: "type", inverse: false}, 
 {key: "title", inverse: false},
 {key: "spot", inverse: false},
 {key: "internal", inverse: true}
]);

enter image description here

Question 35

Look like promising solution but not sure how to use this? I'm doing an angular-ionic project with typescript, in component file how to define this / or add this in project?

Question 36

hi @Hemang, copy the code to a file like array_object_multiple_order.js, import file to your project, now you can call .orderBy from your array of objects

Question 37

Here's a generic multidimensional sort, allowing for reversing and/or mapping on each level.

Written in Typescript. For Javascript, check out this JSFiddle

The Code

type itemMap = (n: any) => any;
interface SortConfig<T> {
 key: keyof T;
 reverse?: boolean;
 map?: itemMap;
}
export function byObjectValues<T extends object>(keys: ((keyof T) | SortConfig<T>)[]): (a: T, b: T) => 0 | 1 | -1 {
 return function(a: T, b: T) {
 const firstKey: keyof T | SortConfig<T> = keys[0];
 const isSimple = typeof firstKey === 'string';
 const key: keyof T = isSimple ? (firstKey as keyof T) : (firstKey as SortConfig<T>).key;
 const reverse: boolean = isSimple ? false : !!(firstKey as SortConfig<T>).reverse;
 const map: itemMap | null = isSimple ? null : (firstKey as SortConfig<T>).map || null;
 const valA = map ? map(a[key]) : a[key];
 const valB = map ? map(b[key]) : b[key];
 if (valA === valB) {
 if (keys.length === 1) {
 return 0;
 }
 return byObjectValues<T>(keys.slice(1))(a, b);
 }
 if (reverse) {
 return valA > valB ? -1 : 1;
 }
 return valA > valB ? 1 : -1;
 };
}

Usage Examples

Sorting a people array by last name, then first name:

interface Person {
 firstName: string;
 lastName: string;
}
people.sort(byObjectValues<Person>(['lastName','firstName']));

Sort language codes by their name, not their language code (see map), then by descending version (see reverse).

interface Language {
 code: string;
 version: number;
}
// languageCodeToName(code) is defined elsewhere in code
languageCodes.sort(byObjectValues<Language>([
 {
 key: 'code',
 map(code:string) => languageCodeToName(code),
 },
 {
 key: 'version',
 reverse: true,
 }
]));

Question 38

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

Demo: http://jsfiddle.net/Nq4dk/2/

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

Question 39

this solution is clean but not performant because of the array comparison. you can simply do a look through properties keep track of the compared value and it its not zero, return. that's a lot faster.

Question 40

Simpler one:

var someArray = [...];
function generateSortFn(props) {
 return function (a, b) {
 for (var i = 0; i < props.length; i++) {
 var prop = props[i];
 var name = prop.name;
 var reverse = prop.reverse;
 if (a[name] < b[name])
 return reverse ? 1 : -1;
 if (a[name] > b[name])
 return reverse ? -1 : 1;
 }
 return 0;
 };
};
someArray.sort(generateSortFn([{name: 'prop1', reverse: true}, {name: 'prop2'}]));

Question 41

why complicate? just sort it twice! this works perfectly: (just make sure to reverse the importance order from least to most):

jj.sort( (a, b) => (a.id >= b.id) ? 1 : -1 );
jj.sort( (a, b) => (a.status >= b.status) ? 1 : -1 );

Question 42

This won't work, comparators are chained together to sort on different levels. The example you have, will sort the array based on id and it will then re-sort based on status. Even if ID of an object is less and its status is greater than other object, it'll come in front. To better understand the question, look at other answers and test your code before posting in here. Thanks

Question 43

My example works. "status" is the primary sort key, and "id" is the secondary, as I wrote just make sure to reverse the importance order from least to most"

Question 44

I needed to sort by 4 fields, this was visually the easiest solution I found

Question 45

I like SnowBurnt's approach but it needs a tweak to test for equivalence on city NOT a difference.

homes.sort(
 function(a,b){
 if (a.city==b.city){
 return (b.price-a.price);
 } else {
 return (a.city-b.city);
 }
 });

Question 46

To make things simple, use these helper functions.

You can sort by as many fields as you need. For each sort field, specify the property name, and then, optionally, specify -1 as the sort direction to sort descending instead of ascending.

const data = [
 {"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"},
 {"h_id":"7","city":"New York","state":"NY","zip":"00010","price":"800500"}
]
const sortLexically = (p,d=1)=>(a,b)=>d * a[p].localeCompare(b[p])
const sortNumerically = (p,d=1)=>(a,b)=>d * (a[p]-b[p])
const sortBy = sorts=>(a,b)=>sorts.reduce((r,s)=>r||s(a,b),0)
// sort first by city, then by price descending
data.sort(sortBy([sortLexically('city'), sortNumerically('price', -1)]))
console.log(data)

Question 47

Very clean, nicest solution here imo. I'll add initialising an Intl.Collator for locale comparison is a lot more efficient than localeCompare

Question 48

Here's my solution based on the Schwartzian transform idiom, hope you find it useful.

function sortByAttribute(array, ...attrs) {
 // generate an array of predicate-objects contains
 // property getter, and descending indicator
 let predicates = attrs.map(pred => {
 let descending = pred.charAt(0) === '-' ? -1 : 1;
 pred = pred.replace(/^-/, '');
 return {
 getter: o => o[pred],
 descend: descending
 };
 });
 // schwartzian transform idiom implementation. aka: "decorate-sort-undecorate"
 return array.map(item => {
 return {
 src: item,
 compareValues: predicates.map(predicate => predicate.getter(item))
 };
 })
 .sort((o1, o2) => {
 let i = -1, result = 0;
 while (++i < predicates.length) {
 if (o1.compareValues[i] < o2.compareValues[i]) result = -1;
 if (o1.compareValues[i] > o2.compareValues[i]) result = 1;
 if (result *= predicates[i].descend) break;
 }
 return result;
 })
 .map(item => item.src);
}

Here's an example how to use it:

let games = [
 { name: 'Pako', rating: 4.21 },
 { name: 'Hill Climb Racing', rating: 3.88 },
 { name: 'Angry Birds Space', rating: 3.88 },
 { name: 'Badland', rating: 4.33 }
];
// sort by one attribute
console.log(sortByAttribute(games, 'name'));
// sort by mupltiple attributes
console.log(sortByAttribute(games, '-rating', 'name'));

Question 49

I tried a few things on this (and other pages). This solution by a8m was only one to work for my situation: gist.github.com/cemerson/f1f1434286c1262b403f3d85c96688e0

Question 50

Just another option. Consider to use the following utility function:

/** Performs comparing of two items by specified properties
 * @param {Array} props for sorting ['name'], ['value', 'city'], ['-date']
 * to set descending order on object property just add '-' at the begining of property
 */
export const compareBy = (...props) => (a, b) => {
 for (let i = 0; i < props.length; i++) {
 const ascValue = props[i].startsWith('-') ? -1 : 1;
 const prop = props[i].startsWith('-') ? props[i].substr(1) : props[i];
 if (a[prop] !== b[prop]) {
 return a[prop] > b[prop] ? ascValue : -ascValue;
 }
 }
 return 0;
};

Example of usage (in your case):

homes.sort(compareBy('city', '-price'));

It should be noted that this function can be even more generalized in order to be able to use nested properties like 'address.city' or 'style.size.width' etc.

Question 51

Nice solution for perfect data but when a key is missing, it will fails the sorting in both the order. Any idea?

Question 52

To fix that problem here is my solution - js.do/hemangshah-in/569879

Question 53

A very intuitive functional solution can be crafted by adding 3 relatively simple helpers. Before we dive in, let's start with the usage:

function usage(homes, { asc, desc, fallback }) {
 homes.sort(fallback(
 asc(home => home.city),
 desc(home => parseInt(home.price, 10)),
 ));
 console.log(homes);
}
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",
}];
const SortHelpers = (function () {
 const asc = (fn) => (a, b) => (a = fn(a), b = fn(b), -(a < b) || +(a > b));
 const desc = (fn) => (a, b) => asc(fn)(b, a);
 const fallback = (...fns) => (a, b) => fns.reduce((diff, fn) => diff || fn(a, b), 0);
 return { asc, desc, fallback };
})();
usage(homes, SortHelpers);

If you scrolled down the snippet you probably already saw the helpers:

const asc = (fn) => (a, b) => (a = fn(a), b = fn(b), -(a < b) || +(a > b));
const desc = (fn) => (a, b) => asc(fn)(b, a);
const fallback = (...fns) => (a, b) => fns.reduce((diff, fn) => diff || fn(a, b), 0);

Let me quickly explain what each of these functions does.

asc creates a comparator function. The provided function fn is called for both the comparator arguments a and b. The results of the two function calls are then compared. -1 is returned if resultA < resultB, 1 is returned if resultA > resultB, or 0 otherwise. These return values correspond with an ascending order direction.

It could also be written like this:
```
function asc(fn) {
 return function (a, b) {
 // apply `fn` to both `a` and `b`
 a = fn(a);
 b = fn(b);
 if (a < b) return -1;
 if (a > b) return 1;
 return 0;
 // or `return -(a < b) || +(a > b)` for short
 };
}
```
desc is super simple, since it just calls asc but swaps the a and b arguments, resulting in descending order instead of ascending.
fallback (there might be a better name for this) allows us to use multiple comparator functions with a single sort.

Both asc and desc can be passed to sort by themself.
```
homes.sort(asc(home => home.city))
```
There is however an issue if you want to combine multiple comparator functions. sort only accepts a single comparator function. fallback combines multiple comparator functions into a single comparator.

The first comparator is called with arguments a and b, if the comparator returns the value 0 (meaning that the values are equal) then we fall back to the next comparator. This continues until a non-0 value is found, or until all comparators are called, in which case the return value is 0.

You can provide your custom comparator functions to fallback() as well. Say you want to use localeCompare() instead of comparing strings with < and >. In such a case you can replace asc(home => home.city) with (a, b) => a.city.localeCompare(b.city).

homes.sort(fallback(
 (a, b) => a.city.localeCompare(b.city),
 desc(home => parseInt(home.price, 10)),
));

One thing to note is that values that can be undefined will always return false when comparing with < and >. So if a value can be missing you might want to sort by its presence first.

homes.sort(fallback(
 // homes with optionalProperty first, true (1) > false (0) so we use desc
 desc(home => home.optionalProperty != null), // checks for both null and undefined
 asc(home => home.optionalProperty),
 // ...
))

Since comparing strings with localeCompare() is such a common thing to do, you could include this as part of asc().

function hasMethod(item, methodName) {
 return item != null && typeof item[methodName] === "function";
}
function asc(fn) {
 return function (a, b) {
 a = fn(a);
 b = fn(b);
 const areLocaleComparable =
 hasMethod(a, "localeCompare") && hasMethod(b, "localeCompare");
 if (areLocaleComparable) return a.localeCompare(b);
 return -(a < b) || +(a > b);
 };
}

Question 54

This deserves more upvotes. Very simple and elegant solution!

Question 55

this method is perfect for me, I use asc function to sort 2 object inside an array, it works perfectly! so like this items.sort(asc(items => items.name)) items.sort(asc(items => items.description)) sorted by name and description. Thanks!

Question 56

my humble proposal:

function cmp(a, b) {
 if (a > b) return 1;
 if (a < b) return -1;
 return 0;
}
function objCmp(a, b, fields) {
 for (let field of fields) {
 let ret = 
 cmp(a[field], b[field]);
 if (ret != 0) {
 return ret;
 }
 }
 return 0;
}

with these two functions, you may sort quite elegantly an array of objects the following way:

let sortedArray = homes.sort(
 (a, b) => objCmp(
 a, b, ['state', 'city'])
);

Question 57

for those whos strugle w nested keys - quite simple w lodash - cmp(_get(a, field), _get(b, field)) and ['state.code', 'city.name']

Question 58

Another way

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"}
 ];
function sortBy(ar) {
 return ar.sort((a, b) => a.city === b.city ?
 b.price.toString().localeCompare(a.price) :
 a.city.toString().localeCompare(b.city));
}
console.log(sortBy(homes));

Question 59

simply follow the list of your sorting criteria

this code will always remain readable and understandable even if you have 36 sorting criteria to encase

The solution proposed here by Nina is certainly very elegant, but it implies knowing that a value of zero corresponds to a value of false in Boolean logic, and that Boolean tests can return something other than true / false in JavaScript (here are numeric values) which will always be confusing for a beginner.

Also think about who will need to maintain your code. Maybe it would be you: imagine yourself spending your days raking for days the code of another and having a pernicious bug ... and you are exhausted from reading these thousands of lines full of tips

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 fSort = (a,b) =>
 {
 let Dx = a.city.localeCompare(b.city) // 1st criteria
 if (Dx===0) Dx = Number(b.price) - Number(a.price) // 2nd
 // if (Dx===0) Dx = ... // 3rd
 // if (Dx===0) Dx = ... // 4th....
 return Dx
 }
console.log( homes.sort(fSort))

Question 60

Adding a couple helper functions lets you solved this kind of problem generically and simply. sortByKey takes an array and a function which should return a list of items with which to compare each array entry.

This takes advantage of the fact that javascript does smart comparison of arrays of simple values, with [2] < [2, 0] < [2, 1] < [10, 0].

// Two helpers:
function cmp(a, b) {
 if (a > b) {
 return 1
 } else if (a < b) {
 return -1
 } else {
 return 0
 }
}
function sortByKey(arr, key) {
 arr.sort((a, b) => cmp(key(a), key(b)))
}
// A demonstration:
let arr = [{a:1, b:2}, {b:3, a:0}, {a:1, b:1}, {a:2, b:2}, {a:2, b:1}, {a:1, b:10}]
sortByKey(arr, item => [item.a, item.b])
console.log(JSON.stringify(arr))
// '[{"b":3,"a":0},{"a":1,"b":1},{"a":1,"b":10},{"a":1,"b":2},{"a":2,"b":1},{"a":2,"b":2}]'
sortByKey(arr, item => [item.b, item.a])
console.log(JSON.stringify(arr))
// '[{"a":1,"b":1},{"a":2,"b":1},{"a":1,"b":10},{"a":1,"b":2},{"a":2,"b":2},{"b":3,"a":0}]'

I've lovingly stolen this idea from Python's list.sort function.

Question 61

This only works with single digit numbers. [1, 0] < [10, 0] < [2, 0]

Question 62

@Coop That's simply untrue. I've updated the answer to demonstrate.

Question 63

I may be misunderstanding but your example appears to be sorting incorrectly. In the first one you see b 10 is before b 2. I can test this in javascript by doing console.log('Check', [2, 0] > [10, 0]) which returns true when it should be false for this method to work correctly.

Question 64

this "smart comparison of arrays of simple values" is performing a simple string-comparison on the stringified arrays. So cmp([1,2,3], [2,3,4]) compares cmp("1,2,3", "2,3,4").

Nina Scholz Nina Scholz 388k26 gold badges367 silver badges416 bronze badges · Accepted Answer · 2017-09-16 16:43:31Z

477

You could use a chained sorting approach by taking the delta of values until it reaches a value not equal to zero.

var data = [{ 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" }];
data.sort(function (a, b) {
 return a.city.localeCompare(b.city) || b.price - a.price;
});
console.log(data);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Or, using es6, simply:

data.sort((a, b) => a.city.localeCompare(b.city) || b.price - a.price);

Share

Improve this answer

edited Aug 23, 2019 at 6:36

answered Sep 16, 2017 at 16:43

Nina Scholz's user avatar

Nina Scholz Nina Scholz

388k26 gold badges367 silver badges416 bronze badges

12

1

what about if order by desc?

Garrod Ran
– Garrod Ran

2021年05月18日 15:42:29 +00:00
Commented May 18, 2021 at 15:42
3

@GarrodRan, switch a and b.

Nina Scholz
– Nina Scholz

2021年05月18日 15:45:03 +00:00
Commented May 18, 2021 at 15:45
3

This is a nice answer - very concise! Maybe worth explaining that it works because zero - as returned by localeCompare() when the two values match - is falsey, while -1 and +1 are truthy.

Dan King
– Dan King

2021年09月10日 13:48:53 +00:00
Commented Sep 10, 2021 at 13:48
1

This is a better solution than my proposal. Good, clean, and fun!

Snowburnt
– Snowburnt

2022年02月16日 15:06:15 +00:00
Commented Feb 16, 2022 at 15:06
1

If one of the field's is a number and you only want to sort by whether it's 0 or greater, then use (b.EstimatedItems > 0) - (a.EstimatedItems > 0) || a.Label.localeCompare(b.Label)). This will sort values with 0 to the bottom first and then sort by the string column.

Zei
– Zei

2023年07月07日 05:09:16 +00:00
Commented Jul 7, 2023 at 5:09

| Show 7 more comments

CollectivesTM on Stack Overflow

How to sort an array of objects by multiple fields?

41 Answers 41

The Code

Usage Examples

Code (TypeScript)

Usage example

Linked

Hot Network Questions

CollectivesTM on Stack Overflow

41 Answers 41

The Code

Usage Examples

Code (TypeScript)

Usage example

Linked

Related