How to sort an array of objects by multiple fields

Question

From this original question  how would I apply a sort on multiple fields   Using this slightly adapted structure  how would I sort city  ascending   amp  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

User · Answer

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   gt  b o   return dir                  if  a o   lt  b o   return - dir                   return 0                              reduce function firstNonZeroValue  p n                    return p   p   n                 0              Edit  in ES6 it s even shorter    x000D   x000D   use strict   x000D  const fieldSorter    fields    gt   a  b    gt  fields map o   gt    x000D      let dir   1  x000D      if  o 0       -     dir   -1  o o substring 1     x000D      return a o   gt  b o    dir   a o   lt  b o    - dir    0  x000D     reduce  p  n    gt  p   p   n  0   x000D   x000D  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    x000D  const sortedHomes   homes sort fieldSorter   state    -price      x000D   x000D  document write   lt pre gt     JSON stringify sortedHomes  null    t       lt  pre gt    x000D   x000D   x000D

User · Answer

Adaptation of  chriskelly  s answer      Most answers overlook that price will not sort properly if the value is in the ten thousands and lower or over a million  The resaon being JS sorts alphabetically  It was answered pretty well here  Why can t JavaScript sort  5  10  1  and here How to sort an array of integers correctly   Ultimately we have to do some evaluation if the field or node we re sorting by is an number  I am not saying that using parseInt   in this case is the correct answer  the sorted results are more important    x000D   x000D  var homes      x000D     h id    2   x000D     city    Dallas   x000D     state    TX   x000D     zip    75201   x000D     price    62500  x000D       x000D     h id    1   x000D     city    Dallas   x000D     state    TX   x000D     zip    75201   x000D     price    62510  x000D       x000D     h id    3   x000D     city    Dallas   x000D     state    TX   x000D     zip    75201   x000D     price    162500  x000D       x000D     h id    4   x000D     city    Bevery Hills   x000D     state    CA   x000D     zip    90210   x000D     price    319250  x000D       x000D     h id    6   x000D     city    Dallas   x000D     state    TX   x000D     zip    75000   x000D     price    556699  x000D       x000D     h id    5   x000D     city    New York   x000D     state    NY   x000D     zip    00010   x000D     price    962500  x000D      x000D   x000D  homes sort fieldSorter   price      x000D     homes sort fieldSorter   zip    -state    price         alternative x000D   x000D  function fieldSorter fields    x000D    return function a  b    x000D      return fields x000D         map function o    x000D          var dir   1  x000D          if  o 0       -     x000D            dir   -1  x000D            o   o substring 1   x000D            x000D          if   parseInt a o    amp  amp   parseInt b o      x000D            if  a o   gt  b o   return dir  x000D            if  a o   lt  b o   return - dir   x000D            return 0  x000D            else   x000D            return dir  gt  0   a o  - b o    b o  - a o   x000D            x000D           x000D         reduce function firstNonZeroValue p  n    x000D          return p   p   n  x000D           0   x000D       x000D    x000D  document getElementById  output   innerHTML     lt pre gt     JSON stringify homes  null    t       lt  pre gt    x000D   lt div id  output  gt  x000D   x000D   lt  div gt  x000D   x000D   x000D      A fiddle to test with

User · Answer

function sortMultiFields prop       return function a b           for i 0 i lt prop length i                          var reg      d                 var x 1              var field1 prop i               if prop i  indexOf  -    0                                field1 prop i  substr 1 prop i  length                   x -x                             if reg test a field1                                  a field1  parseFloat a field1                    b field1  parseFloat b field1                              if  a field1   gt  b field1                   return x              else if a field1   lt  b field1                   return -x                      How to use  put - minus  sign before field if you want to sort in descending order particular field   homes sort sortMultiFields   city   -price        Using above function you can sort any json array with multiple fields  No need to change function body at all

User · Answer

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  lt  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  lt  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  lt  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  lt  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 lt b  result   reverse   -1             if  a gt b  result   reverse   1             if result     0  break                  return result            DEMO

User · Answer

Another way   x000D   x000D  var homes     x000D        h id   3   x000D        city   Dallas   x000D        state   TX   x000D        zip   75201   x000D        price   162500    x000D        h id   4   x000D        city   Bevery Hills   x000D        state   CA   x000D        zip   90210   x000D        price   319250    x000D        h id   6   x000D        city   Dallas   x000D        state   TX   x000D        zip   75000   x000D        price   556699    x000D        h id   5   x000D        city   New York   x000D        state   NY   x000D        zip   00010   x000D        price   962500   x000D         x000D  function sortBy ar    x000D    return ar sort  a  b    gt  a city     b city   x000D        b price toString   localeCompare a price    x000D        a city toString   localeCompare b city    x000D    x000D  console log sortBy homes    x000D   x000D   x000D

User · Answer

You could use a chained sorting approach by taking the delta of values until it reaches a value not equal to zero    x000D   x000D  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      x000D   x000D  data sort function  a  b    x000D      return a city localeCompare b city     b price - a price  x000D      x000D   x000D  console log data   x000D   as-console-wrapper   max-height  100   important  top  0    x000D   x000D   x000D    Or  using es6  simply   data sort  a  b    gt  a city localeCompare b city     b price - a price

User · Answer

function sort data  orderBy            orderBy   Array isArray orderBy    orderBy    orderBy           return data sort  a  b    gt                for  let i   0  size   orderBy length  i  lt  size  i                      const key   Object keys orderBy i   0                       o   orderBy i  key                       valueA   a key                       valueB   b key                   if    valueA    valueB                         console error  the objects from the data passed does not have the key      key      passed on sort                         return                                       if   valueA      valueA                        return o toLowerCase        desc    valueB - valueA   valueA - valueB                    else                       if  valueA localeCompare valueB   gt  0                            return o toLowerCase        desc    -1   1                        else if  valueA localeCompare valueB   lt  0                            return o toLowerCase        desc    1   -1                                                                            Using    sort homes    city    asc     price   desc        x000D   x000D  var homes     x000D        h id   3   x000D        city   Dallas   x000D        state   TX   x000D        zip   75201   x000D        price   162500    x000D        h id   4   x000D        city   Bevery Hills   x000D        state   CA   x000D        zip   90210   x000D        price   319250    x000D        h id   6   x000D        city   Dallas   x000D        state   TX   x000D        zip   75000   x000D        price   556699    x000D        h id   5   x000D        city   New York   x000D        state   NY   x000D        zip   00010   x000D        price   962500   x000D         x000D  function sort data  orderBy    x000D              orderBy   Array isArray orderBy    orderBy    orderBy   x000D              return data sort  a  b    gt    x000D                  for  let i   0  size   orderBy length  i  lt  size  i      x000D                      const key   Object keys orderBy i   0   x000D                          o   orderBy i  key   x000D                          valueA   a key   x000D                          valueB   b key   x000D                      if    valueA    valueB     x000D                          console error  the objects from the data passed does not have the key      key      passed on sort     x000D                          return     x000D                        x000D                      if   valueA      valueA    x000D                          return o toLowerCase        desc    valueB - valueA   valueA - valueB  x000D                        else   x000D                          if  valueA localeCompare valueB   gt  0    x000D                              return o toLowerCase        desc    -1   1  x000D                            else if  valueA localeCompare valueB   lt  0    x000D                              return o toLowerCase        desc    1   -1  x000D                            x000D                        x000D                    x000D                  x000D            x000D  console log sort homes    city    asc     price   desc       x000D   x000D   x000D

User · Answer

Simpler one   var someArray           function generateSortFn props        return function  a  b            for  var i   0  i  lt  props length  i                  var prop   props i               var name   prop name              var reverse   prop reverse              if  a name   lt  b name                   return reverse   1   -1              if  a name   gt  b name                   return reverse   -1   1                    return 0             someArray sort generateSortFn   name   prop1   reverse  true    name   prop2

User · Answer

Wow  there are some complex solutions here  So complex I decided to come up with something simpler but also quite powerful  Here it is   function sortByPriority data  priorities      if  priorities length    0        return data         const nextPriority   priorities 0     const remainingPriorities   priorities slice 1      const matched   data filter item   gt  item hasOwnProperty nextPriority      const remainingData   data filter item   gt   item hasOwnProperty nextPriority       return sortByPriority matched  remainingPriorities       sort  a  b    gt   a nextPriority   gt  b nextPriority     1   -1       concat sortByPriority remainingData  remainingPriorities        And here is an example of how you use it   const data         id  1                          mediumPriority   bbb   lowestPriority   ggg         id  2  highestPriority   bbb   mediumPriority   ccc   lowestPriority   ggg         id  3                          mediumPriority   aaa   lowestPriority   ggg         const priorities        highestPriority      mediumPriority      lowestPriority       const sorted   sortByPriority data  priorities     This will first sort by the precedence of the attributes  then by the value of the attributes

User · Answer

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      Object defineProperty Array prototype   orderBy     value  function sorts         sorts map sort   gt                        sort uniques   Array from              new Set this map obj   gt  obj sort key                        sort uniques   sort uniques sort  a  b    gt                if  typeof a     string                     return sort inverse   b localeCompare a    a localeCompare b                             else if  typeof a     number                     return sort inverse    a  lt  b     a  gt  b   1   0                             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    gt            let weight               sorts map sort   gt                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    gt            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

User · Answer

Here  AffiliateDueDate  and  Title  are columns  both are sorted in ascending order   array sort function a  b                    if  a AffiliateDueDate  gt  b AffiliateDueDate   return 1                 else if  a AffiliateDueDate  lt  b AffiliateDueDate   return -1                 else if  a Title  gt  b Title   return 1                 else if  a Title  lt  b Title   return -1                 else return 0

User · Answer

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

User · Answer

I think this may be the easiest way to do it.

https://coderwall.com/p/ebqhca/javascript-sort-by-two-fields

It's really simple and I tried it with 3 different key value pairs and it worked great.

Here is a simple example, look at the link for more details

testSort(data) {
    return data.sort(
        a['nameOne'] > b['nameOne'] ? 1
        : b['nameOne'] > a['nameOne'] ? -1 : 0 ||
        a['date'] > b['date'] ||
        a['number'] - b['number']
    );
}

User · Answer

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    gt   a  b    gt      for  let i   0  i  lt  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   gt  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

User · Answer

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

User · Answer

I was looking for something similar and ended up with this:

First we have one or more sorting functions, always returning either 0, 1 or -1:

const sortByTitle = (a, b): number => 
  a.title === b.title ? 0 : a.title > b.title ? 1 : -1;

You can create more functions for each other property you want to sort on.

Then I have a function that combines these sorting functions into one:

const createSorter = (...sorters) => (a, b) =>
  sorters.reduce(
    (d, fn) => (d === 0 ? fn(a, b) : d),
    0
  );

This can be used to combine the above sorting functions in a readable way:

const sorter = createSorter(sortByTitle, sortByYear)

items.sort(sorter)

When a sorting function returns 0 the next sorting function will be called for further sorting.

User · Answer

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

User · Answer

Here is mine for your reference  with example   function msort arr     compFns      let fn   compFns 0     arr      concat arr     let arr1         while  arr length  gt  0        let arr2   arr splice 0  1       for  let i   arr length  i  gt  0           if  fn arr2 0   arr --i       0            arr2   arr2 concat arr splice i  1                      arr1 push arr2          arr1 sort function  a  b        return fn a 0   b 0             compFns   compFns slice 1     let res         arr1 map a1   gt        if  compFns length  gt  0  a1   msort a1     compFns       a1 map a2   gt  res push a2            return res     let tstArr      id  1  sex   o       id  2  sex   m       id  3  sex   m       id  4  sex   f       id  5  sex   m       id  6  sex   o       id  7  sex   f       function tstFn1 a  b      if  a sex  gt  b sex  return 1    else if  a sex  lt  b sex  return -1    return 0     function tstFn2 a  b      if  a id  gt  b id  return -1    else if  a id  lt  b id  return 1    return 0     console log JSON stringify msort tstArr  tstFn1  tstFn2       output       id  7  sex   f     id  4  sex   f     id  5  sex   m     id  3  sex   m     id  2  sex   m     id  6  sex   o     id  1  sex   o

User · Answer

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   gt        let descending   pred charAt 0       -    -1   1      pred   pred replace   -            return         getter  o   gt  o pred         descend  descending                   schwartzian transform idiom implementation  aka   decorate-sort-undecorate    return array map item   gt        return         src  item        compareValues  predicates map predicate   gt  predicate getter item                  sort  o1  o2    gt        let i   -1  result   0      while    i  lt  predicates length          if  o1 compareValues i   lt  o2 compareValues i   result   -1        if  o1 compareValues i   gt  o2 compareValues i   result   1        if  result    predicates i  descend  break            return result          map item   gt  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

User · Answer

Simplest Way to sort array of object by multiple fields   let homes       quot h id quot   quot 3 quot       quot city quot   quot Dallas quot       quot state quot   quot TX quot       quot zip quot   quot 75201 quot       quot price quot   quot 162500 quot        quot h id quot   quot 4 quot       quot city quot   quot Bevery Hills quot       quot state quot   quot CA quot       quot zip quot   quot 90210 quot       quot price quot   quot 319250 quot        quot h id quot   quot 6 quot       quot city quot   quot Dallas quot       quot state quot   quot TX quot       quot zip quot   quot 75000 quot       quot price quot   quot 556699 quot        quot h id quot   quot 5 quot       quot city quot   quot New York quot       quot state quot   quot NY quot       quot zip quot   quot 00010 quot       quot price quot   quot 962500 quot         homes sort  a  b    gt   a city  gt  b city    1   -1    Output   quot Bevery Hills quot   quot Dallas quot   quot Dallas quot   quot Dallas quot   quot New York quot

User · Answer

Sorting on two date fields and a numeric field example:

var generic_date =  new Date(2070, 1, 1);
checkDate = function(date) {
  return Date.parse(date) ? new Date(date): generic_date;
}

function sortData() {  
  data.sort(function(a,b){
    var deltaEnd = checkDate(b.end) - checkDate(a.end);
    if(deltaEnd) return deltaEnd;

    var deltaRank = a.rank - b.rank;
    if (deltaRank) return deltaRank;

    var deltaStart = checkDate(b.start) - checkDate(a.start);
    if(deltaStart) return deltaStart;

    return 0;
  });
}

http://jsfiddle.net/hcWgf/57/

User · Answer

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    gt  any   interface SortConfig lt T gt      key  keyof T    reverse   boolean    map   itemMap     export function byObjectValues lt T extends object gt  keys    keyof T    SortConfig lt T gt        a  T  b  T    gt  0   1   -1     return function a  T  b  T        const firstKey  keyof T   SortConfig lt T gt    keys 0       const isSimple   typeof firstKey      string       const key  keyof T   isSimple    firstKey as keyof T     firstKey as SortConfig lt T gt   key      const reverse  boolean   isSimple   false      firstKey as SortConfig lt T gt   reverse      const map  itemMap   null   isSimple   null    firstKey as SortConfig lt T gt   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 lt T gt  keys slice 1   a  b             if  reverse          return valA  gt  valB   -1   1            return valA  gt  valB   1   -1           Usage Examples  Sorting a people array by last name  then first name   interface Person     firstName  string    lastName  string     people sort byObjectValues lt Person gt    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 lt Language gt            key   code       map code string    gt  languageCodeToName code                key   version       reverse  true

User · Answer

Here s an extensible way to sort 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 lt b a  b a gt b  Subtraction works on numeric fields  because a - b gives - 0   if a lt b a  b a gt b     in the last line gives city priority over price  Negate to reverse order in any field  as in -price order Date comparison  var date order   new Date left date  - new Date right date   works like numerics because date math turns into milliseconds since 1970  Add fields into the or-chain  return city order    -price order    date order  Subtraction works on boolean  I suggest you make it explicit  var goodness order   Boolean left is good  - Boolean right is good

User · Answer

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.

User · Answer

Here is a generic version of  Snowburnt s solution   var sortarray     field  city   direction  asc     field  price   direction  desc     array sort function a b       for var i 0  i lt sortarray length  i             retval   a sortarray i  field   lt  b sortarray i  field    -1   a sortarray i  field   gt  b sortarray i  field    1   0          if  sortarray i  direction     desc                 retval   retval   -1                    if  retval     0                return retval                           This is based on a sort routine I m using   I didn t test this specific code so it may have errors but you get the idea   The idea is to sort based on the first field that indicates a difference and then stop and go to the next record   So  if you re sorting by three fields and the first field in the compare is enough to determine the sort order of the two records being sorted then return that sort result and go to the next record     I tested it  actually with a little more complex sort logic  on 5000 records and it did it in the blink of an eye   If you re actually loading more than 1000 records to the client you should probably be using sever-side sorting and filtering   This code isn t handling case-sensitivity but I leave it to the reader to handle this trivial modification

User · Answer

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  gt  b city   1   -1

User · Answer

This is a recursive algorithm to sort by multiple fields while having the chance to format values before comparison.

var data = [
{
    "id": 1,
    "ship": null,
    "product": "Orange",
    "quantity": 7,
    "price": 92.08,
    "discount": 0
},
{
    "id": 2,
    "ship": "2017-06-14T23:00:00.000Z".toDate(),
    "product": "Apple",
    "quantity": 22,
    "price": 184.16,
    "discount": 0
},
...
]
var sorts = ["product", "quantity", "ship"]

// comp_val formats values and protects against comparing nulls/undefines
// type() just returns the variable constructor
// String.lower just converts the string to lowercase.
// String.toDate custom fn to convert strings to Date
function comp_val(value){
    if (value==null || value==undefined) return null
    var cls = type(value)
    switch (cls){
        case String:
            return value.lower()
    }
    return value
}

function compare(a, b, i){
    i = i || 0
    var prop = sorts[i]
    var va = comp_val(a[prop])
    var vb = comp_val(b[prop])

    // handle what to do when both or any values are null
    if (va == null || vb == null) return true

    if ((i < sorts.length-1) && (va == vb)) {
        return compare(a, b, i+1)
    } 
    return va > vb
}

var d = data.sort(compare);
console.log(d);

If a and b are equal it will just try the next field until none is available.

User · Answer

homes sort function a b    return a city - b city      homes sort function a b       if  a city  b city           return parseFloat b price  - parseFloat a price         else           return 0

User · Answer

How about this simple solution    const sortCompareByCityPrice    a  b    gt        let comparison   0        sort by first criteria     if  a city  gt  b city            comparison   1           else if  a city  lt  b city            comparison   -1              If still 0 then sort by second criteria descending     if  comparison     0            if  parseInt a price   gt  parseInt b price                 comparison   -1                   else if  parseInt a price   lt  parseInt b price                 comparison   1                     return comparison      Based on this question javascript sort array by multiple  number  fields

User · Answer

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  gt  y   1   x  lt  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  lt  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   amp  amp  prop 2  toLowerCase        desc                  return  prop 1    -1             else               return  prop 1    1                          function valueCmp x  y            return x  gt  y   1   x  lt  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  lt  arr2   -1   1             objArray sort function a  b            return arrayCmp a  b

[javascript] How to sort an array of objects by multiple fields?

The answer is

The Code

Usage Examples

Examples related to javascript

Examples related to arrays

Examples related to sorting

Tags