Most efficient method to groupby on an array of objects

Question

What is the most efficient way to groupby objects in an array   For example  given this array of objects            Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5           Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10           Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15           Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20           Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25           Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30           Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35           Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40        I   m displaying this information in a table  I   d like to groupby different methods  but I want to sum the values   I   m using Underscore js for its groupby function  which is helpful  but doesn   t do the whole trick  because I don   t want them    split up    but    merged     more like the SQL group by method   What I   m looking for would be able to total specific values  if requested    So if I did groupby Phase  I   d want to receive           Phase   Phase 1   Value  50          Phase   Phase 2   Value  130       And if I did groupy Phase   Step  I   d receive           Phase   Phase 1   Step   Step 1   Value  15          Phase   Phase 1   Step   Step 2   Value  35          Phase   Phase 2   Step   Step 1   Value  55          Phase   Phase 2   Step   Step 2   Value  75       Is there a helpful script for this  or should I stick to using Underscore js  and then looping through the resulting object to do the totals myself

User · Answer

With sort feature  export const groupBy   function groupByArray xs  key  sortKey          return xs reduce function rv  x            let v   key instanceof Function   key x    x key           let el   rv find r   gt  r  amp  amp  r key     v            if  el              el values push x             el values sort function a  b                return a sortKey  toLowerCase   localeCompare b sortKey  toLowerCase                             else             rv push   key  v  values   x                         return rv                         Sample   var state                 name   Arkansas         population   2 978M         flag     https   upload wikimedia org wikipedia commons 9 9d Flag of Arkansas svg         category   city                name   Crkansas         population   2 978M         flag           https   upload wikimedia org wikipedia commons 9 9d Flag of Arkansas svg         category   city                     name   Balifornia         population   39 14M         flag           https   upload wikimedia org wikipedia commons 0 01 Flag of California svg         category   city                     name   Florida         population   20 27M         flag           https   upload wikimedia org wikipedia commons f f7 Flag of Florida svg         category   airport                     name   Texas         population   27 47M         flag           https   upload wikimedia org wikipedia commons f f7 Flag of Texas svg         category   landmark             console log JSON stringify groupBy state  category   name

User · Answer

just simple if you use lodash library  let temp          map yourCollectionData   row    gt        let index     findIndex temp     Phase   row Phase        if  index  gt  -1          temp index  Value    row Value        else         temp push row

User · Answer

From  mortb   jmarceli answer and from this post   I take the advantage of JSON stringify   to be the identity for the PRIMITIVE VALUE multiple columns of group by   Without third-party  function groupBy list  keyGetter        const map   new Map        list forEach  item    gt            const key   keyGetter item           if   map has key                 map set key   item              else               map get key  push item                         return map     const pets          type  Dog   age  3  name  Spot         type  Cat   age  3  name  Tiger         type  Dog   age  4  name  Rover          type  Cat   age  3  name  Leo       const grouped   groupBy pets  pet   gt  JSON stringify   type  pet type  age  pet age       console log grouped     With Lodash third-party  const pets          type  Dog   age  3  name  Spot         type  Cat   age  3  name  Tiger         type  Dog   age  4  name  Rover          type  Cat   age  3  name  Leo       let rslt     groupBy pets  pet   gt  JSON stringify     type  pet type  age  pet age       console log rslt

User · Answer

In my particular usecase  I needed to group by a property and then remove the grouping property  That property was only added to the record for grouping purposes anyway and it wouldn t make sense for presentation to a user      group  arr  key             let prop           return arr reduce function rv  x                prop   x key               delete x key                rv prop     rv prop          push x               return rv                           Credit to  caesar-bautista for the starting function in the top answer

User · Answer

I don t think that given answers are responding to the question  I think this following should answer to the first part    x000D   x000D  const arr        Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5       Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10       Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15       Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20       Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25       Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30       Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35       Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40       const groupBy    key    gt  arr reduce  total  currentValue    gt      const newTotal   total    if       total length  amp  amp      total total length - 1  key      currentValue key          newTotal total length - 1               total total length - 1            currentValue        Value  parseInt total total length - 1  Value    parseInt currentValue Value            else newTotal total length    currentValue    return newTotal           console log groupBy  Phase           gt     Phase   Phase 1   Value  50     Phase   Phase 2   Value  130    x000D   x000D   x000D

User · Answer

GroupBy one-liner  a ES2021 solution const groupBy    x f   gt x reduce  a b   gt   a f b         push b  a        EXAMPLES const groupBy    x  f    gt  x reduce  a  b    gt    a f b           push b   a           f - gt  should must return string number because it will be use as key in object     for demo  groupBy  1  2  3  4  5  6  7  8  9   v   gt   v   2    quot odd quot     quot even quot          odd   1  3  5  7  9   even   2  4  6  8     const colors        quot Apricot quot      quot Brown quot      quot Burgundy quot      quot Cerulean quot      quot Peach quot      quot Pear quot      quot Red quot       groupBy colors  v   gt  v 0       group by colors name first letter           A    quot Apricot quot         B    quot Brown quot    quot Burgundy quot         C    quot Cerulean quot         P    quot Peach quot    quot Pear quot         R    quot Red quot          groupBy colors  v   gt  v length      group by length of color names           3    quot Red quot         4    quot Pear quot         5    quot Brown quot    quot Peach quot         7    quot Apricot quot         8    quot Burgundy quot    quot Cerulean quot          const data         comment   quot abc quot   forItem  1  inModule  1        comment   quot pqr quot   forItem  1  inModule  1        comment   quot klm quot   forItem  1  inModule  2        comment   quot xyz quot   forItem  1  inModule  2        groupBy data  v   gt  v inModule      group by module           1             comment   quot abc quot   forItem  1  inModule  1             comment   quot pqr quot   forItem  1  inModule  1                 2             comment   quot klm quot   forItem  1  inModule  2             comment   quot xyz quot   forItem  1  inModule  2                  groupBy data  x   gt  x forItem    quot - quot    x inModule      group by module with item            quot 1-1 quot              comment   quot abc quot   forItem  1  inModule  1             comment   quot pqr quot   forItem  1  inModule  1                  quot 2-1 quot              comment   quot klm quot   forItem  1  inModule  2             comment   quot xyz quot   forItem  1  inModule  2

User · Answer

x000D   x000D  Array prototype groupBy   function  groupingKeyFn    x000D      if  typeof groupingKeyFn      function     x000D          throw new Error  groupBy take a function as only parameter    x000D        x000D      return this reduce  result  item    gt    x000D          let key   groupingKeyFn item   x000D          if   result key   x000D              result key        x000D          result key  push item   x000D          return result  x000D              x000D    x000D   x000D  var a     x000D    type   video   name   a    x000D     type   image   name   b    x000D     type   video   name   c    x000D     type   blog   name   d    x000D     type   video   name   e    x000D    x000D  console log a groupBy  item    gt  item type    x000D   lt script src  https   ajax googleapis com ajax libs jquery 2 1 1 jquery min js  gt  lt  script gt  x000D   x000D   x000D

User · Answer

function groupBy array  groupBy           return array reduce  acc curr index array    gt               var  idx   curr groupBy                  if  acc idx                        acc idx    array filter item   gt  item groupBy      idx                               return  acc                            call groupBy items  Step

User · Answer

Although the linq answer is interesting  it s also quite heavy-weight   My approach is somewhat different   var DataGrouper    function         var has   function obj  target            return   any obj  function value                return   isEqual value  target                           var keys   function data  names            return   reduce data  function memo  item                var key     pick item  names               if   has memo  key                     memo push key                             return memo                              var group   function data  names            var stems   keys data  names           return   map stems  function stem                return                   key  stem                  vals   map   where data  stem   function item                        return   omit item  names                                                             group register   function name  converter            return group name    function data  names                return   map group data  names   converter                          return group         DataGrouper register  sum   function item        return   extend     item key   Value    reduce item vals  function memo  node            return memo   Number node Value          0           You can see it in action on JSBin   I didn t see anything in Underscore that does what has does  although I might be missing it   It s much the same as   contains  but uses   isEqual rather than     for comparisons   Other than that  the rest of this is problem-specific  although with an attempt to be generic   Now DataGrouper sum data    Phase    returns         Phase   Phase 1   Value  50        Phase   Phase 2   Value  130      And DataGrouper sum data    Phase    Step    returns         Phase   Phase 1   Step   Step 1   Value  15        Phase   Phase 1   Step   Step 2   Value  35        Phase   Phase 2   Step   Step 1   Value  55        Phase   Phase 2   Step   Step 2   Value  75        But sum is only one potential function here   You can register others as you like   DataGrouper register  max   function item        return   extend     item key   Max    reduce item vals  function memo  node            return Math max memo  Number node Value           Number NEGATIVE INFINITY           and now DataGrouper max data    Phase    Step    will return         Phase   Phase 1   Step   Step 1   Max  10        Phase   Phase 1   Step   Step 2   Max  20        Phase   Phase 2   Step   Step 1   Max  30        Phase   Phase 2   Step   Step 2   Max  40      or if you registered this   DataGrouper register  tasks   function item        return   extend     item key   Tasks    map item vals  function item          return item Task          item Value               join                then calling DataGrouper tasks data    Phase    Step    will get you         Phase   Phase 1   Step   Step 1   Tasks   Task 1  5   Task 2  10          Phase   Phase 1   Step   Step 2   Tasks   Task 1  15   Task 2  20          Phase   Phase 2   Step   Step 1   Tasks   Task 1  25   Task 2  30          Phase   Phase 2   Step   Step 2   Tasks   Task 1  35   Task 2  40        DataGrouper itself is a function   You can call it with your data and a list of the properties you want to group by   It returns an array whose elements are object with two properties  key is the collection of grouped properties  vals is an array of objects containing the remaining properties not in the key   For example  DataGrouper data    Phase    Step    will yield                    key    Phase   Phase 1   Step   Step 1             vals                  Task   Task 1   Value   5                 Task   Task 2   Value   10                                   key    Phase   Phase 1   Step   Step 2             vals                  Task   Task 1   Value   15                  Task   Task 2   Value   20                                   key    Phase   Phase 2   Step   Step 1             vals                  Task   Task 1   Value   25                 Task   Task 2   Value   30                                   key    Phase   Phase 2   Step   Step 2             vals                  Task   Task 1   Value   35                  Task   Task 2   Value   40                       DataGrouper register accepts a function and creates a new function which accepts the initial data and the properties to group by   This new function then takes the output format as above and runs your function against each of them in turn  returning a new array   The function that s generated is stored as a property of DataGrouper according to a name you supply and also returned if you just want a local reference   Well that s a lot of explanation   The code is reasonably straightforward  I hope

User · Answer

Following Joseph Nields answer there s a polyfill for grouping objects in https   github com padcom array-prototype-functions arrayprototypegroupbyfieldormapper  So instead of writing that over and over again you might want to use what s already available

User · Answer

data     id 1  name  BMW     id 2  name  AN     id 3  name  BMW     id 1  name  NNN    key    id   try by id or name data reduce  previous  current   gt       previous current key    amp  amp  previous current key   length    0   previous current key   push current    previous current key     new Array current      return previous

User · Answer

Although the question have some answers and the answers look a bit over complicated  I suggest to use vanilla Javascript for group-by with a nested  if necessary  Map    x000D   x000D  function groupBy array  groups  valueKey    x000D      var map   new Map  x000D      groups      concat groups   x000D      return array reduce  r  o    gt    x000D          groups reduce  m  k  i    length      gt    x000D              var child  x000D              if  m has o k    return m get o k    x000D              if  i   1     length    x000D                  child   Object x000D                       assign    groups map k   gt      k   o k          valueKey   0     x000D                  r push child   x000D                else   x000D                  child   new Map  x000D                x000D              m set o k   child   x000D              return child  x000D             map  valueKey      o valueKey   x000D          return r  x000D             x000D     x000D   x000D  var data      Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5       Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10       Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15       Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20       Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25       Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30       Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35       Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40      x000D   x000D  console log groupBy data   Phase    Value     x000D  console log groupBy data    Phase    Step     Value     x000D   as-console-wrapper   max-height  100   important  top  0    x000D   x000D   x000D

User · Answer

Just to add to Scott Sauyet s answer  some people were asking in the comments how to use his function to groupby value1  value2  etc   instead of grouping just one value   All it takes is to edit his sum function   DataGrouper register  sum   function item        return   extend     item key           VALUE1    reduce item vals  function memo  node            return memo   Number node VALUE1     0             VALUE2    reduce item vals  function memo  node            return memo   Number node VALUE2     0                leaving the main one  DataGrouper  unchanged   var DataGrouper    function         var has   function obj  target            return   any obj  function value                return   isEqual value  target                           var keys   function data  names            return   reduce data  function memo  item                var key     pick item  names               if   has memo  key                     memo push key                             return memo                              var group   function data  names            var stems   keys data  names           return   map stems  function stem                return                   key  stem                  vals   map   where data  stem   function item                        return   omit item  names                                                             group register   function name  converter            return group name    function data  names                return   map group data  names   converter                          return group

User · Answer

Let s fully answer the original question while reusing code that was already written  i e   Underscore   You can do much more with Underscore if you combine its  gt 100 functions  The following solution demonstrates this  Step 1  group the objects in the array by an arbitrary combination of properties  This uses the fact that   groupBy accepts a function that returns the group of an object  It also uses   chain    pick    values    join and   value  Note that   value is not strictly needed here  because chained values will automatically unwrap when used as a property name  I m including it to safeguard against confusion in case somebody tries to write similar code in a context where automatic unwrapping does not take place     Given an object  return a string naming the group it belongs to  function category obj        return   chain obj  pick propertyNames  values   join      value          Perform the grouping  const intermediate     groupBy arrayOfObjects  category    Given the arrayOfObjects in the original question and setting propertyNames to   Phase    Step    intermediate will get the following value         quot Phase 1 Step 1 quot               Phase   quot Phase 1 quot   Step   quot Step 1 quot   Task   quot Task 1 quot   Value   quot 5 quot               Phase   quot Phase 1 quot   Step   quot Step 1 quot   Task   quot Task 2 quot   Value   quot 10 quot                quot Phase 1 Step 2 quot               Phase   quot Phase 1 quot   Step   quot Step 2 quot   Task   quot Task 1 quot   Value   quot 15 quot               Phase   quot Phase 1 quot   Step   quot Step 2 quot   Task   quot Task 2 quot   Value   quot 20 quot                quot Phase 2 Step 1 quot               Phase   quot Phase 2 quot   Step   quot Step 1 quot   Task   quot Task 1 quot   Value   quot 25 quot               Phase   quot Phase 2 quot   Step   quot Step 1 quot   Task   quot Task 2 quot   Value   quot 30 quot                quot Phase 2 Step 2 quot               Phase   quot Phase 2 quot   Step   quot Step 2 quot   Task   quot Task 1 quot   Value   quot 35 quot               Phase   quot Phase 2 quot   Step   quot Step 2 quot   Task   quot Task 2 quot   Value   quot 40 quot             Step 2  reduce each group to a single flat object and return the results in an array  Besides the functions we have seen before  the following code uses   pluck    first    pick    extend    reduce and   map    first is guaranteed to return an object in this case  because   groupBy does not produce empty groups    value is necessary in this case     Sum two numbers  even if they are contained in strings  const addNumeric    a  b    gt   a    b      Given a  group  of objects  return a flat object with their common    properties and the sum of the property with name  aggregateProperty   function summarize group        const valuesToSum     pluck group  aggregateProperty       return   chain group  first   pick propertyNames  extend            aggregateProperty     reduce valuesToSum  addNumeric         value          Get an array with all the computed aggregates  const result     map intermediate  summarize    Given the intermediate that we obtained before and setting aggregateProperty to Value  we get the result that the asker desired          Phase   quot Phase 1 quot   Step   quot Step 1 quot   Value  15          Phase   quot Phase 1 quot   Step   quot Step 2 quot   Value  35          Phase   quot Phase 2 quot   Step   quot Step 1 quot   Value  55          Phase   quot Phase 2 quot   Step   quot Step 2 quot   Value  75      We can put this all together in a function that takes arrayOfObjects  propertyNames and aggregateProperty as parameters  Note that arrayOfObjects can actually also be a plain object with string keys  because   groupBy accepts either  For this reason  I have renamed arrayOfObjects to collection  function aggregate collection  propertyNames  aggregateProperty        function category obj            return   chain obj  pick propertyNames  values   join                 const addNumeric    a  b    gt   a    b      function summarize group            const valuesToSum     pluck group  aggregateProperty           return   chain group  first   pick propertyNames  extend                aggregateProperty     reduce valuesToSum  addNumeric             value              return   chain collection  groupBy category  map summarize  value       aggregate arrayOfObjects    Phase    Step     Value   will now give us the same result again  We can take this a step further and enable the caller to compute any statistic over the values in each group  We can do this and also enable the caller to add arbitrary properties to the summary of each group  We can do all of this while making our code shorter  We replace the aggregateProperty parameter by an iteratee parameter and pass this straight to   reduce  function aggregate collection  propertyNames  iteratee        function category obj            return   chain obj  pick propertyNames  values   join                 function summarize group            return   chain group  first   pick propertyNames               extend   reduce group  iteratee   value              return   chain collection  groupBy category  map summarize  value       In effect  we move some of the responsibility to the caller  she must provide an iteratee that can be passed to   reduce  so that the call to   reduce will produce an object with the aggregate properties she wants to add  For example  we obtain the same result as before with the following expression  aggregate arrayOfObjects    Phase    Step     memo  value    gt         Value   memo Value    value Value       For an example of a slightly more sophisticated iteratee  suppose that we want to compute the maximum Value of each group instead of the sum  and that we want to add a Tasks property that lists all the values of Task that occur in the group  Here s one way we can do this  using the last version of aggregate above  and   union   aggregate arrayOfObjects    Phase    Step     memo  value    gt         Value  Math max memo Value  value Value       Tasks    union memo Tasks     memo Task    value Task         We obtain the following result          Phase   quot Phase 1 quot   Step   quot Step 1 quot   Value  10  Tasks     quot Task 1 quot    quot Task 2 quot             Phase   quot Phase 1 quot   Step   quot Step 2 quot   Value  20  Tasks     quot Task 1 quot    quot Task 2 quot             Phase   quot Phase 2 quot   Step   quot Step 1 quot   Value  30  Tasks     quot Task 1 quot    quot Task 2 quot             Phase   quot Phase 2 quot   Step   quot Step 2 quot   Value  40  Tasks     quot Task 1 quot    quot Task 2 quot         Credit to  much2learn  who also posted an answer that can handle arbitrary reducing functions  I wrote a couple more SO answers that demonstrate how one can achieve sophisticated things by combining multiple Underscore functions   https   stackoverflow com a 64938636 1166087 https   stackoverflow com a 64094738 1166087 https   stackoverflow com a 63625129 1166087 https   stackoverflow com a 63088916 1166087

User · Answer

I borrowed this method from underscore js fiddler  window helpers  function         var lookupIterator   function value            if  value    null               return function value                    return value                                   if  typeof value      function                    return value                    return function obj                return obj value                         each   function obj  iterator  context            var breaker               if  obj    null  return obj          if  Array prototype forEach  amp  amp  obj forEach     Array prototype forEach                obj forEach iterator  context             else if  obj length      obj length                for  var i   0  length   obj length  i  lt  length  i                      if  iterator call context  obj i   i  obj      breaker  return                          else               var keys                  for  var key in obj  if  Object prototype hasOwnProperty call obj  key   keys push key              for  var i   0  length   keys length  i  lt  length  i                      if  iterator call context  obj keys i    keys i   obj      breaker  return                                  return obj                An internal function used for aggregate  group by  operations      group   function behavior            return function obj  iterator  context                var result                   iterator   lookupIterator iterator               each obj  function value  index                    var key   iterator call context  value  index  obj                   behavior result  key  value                               return result                         return         groupBy   group function result  key  value            Object prototype hasOwnProperty call result  key    result key  push value                 result key     value                            var arr   a 1 b 2   a 1 b 3   a 1 b 1   a 1 b 2   a 1 b 3     console dir helpers groupBy arr  b      console dir helpers groupBy arr function  el      return el b gt 2

User · Answer

You can do it with Alasql JavaScript library   var data       Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5                    Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10       var res   alasql  SELECT Phase  Step  SUM CAST  Value  AS INT   AS  Value                      FROM   GROUP BY Phase  Step   data      Try this example at jsFiddle   BTW  On large arrays  100000 records and more  Alasql faster tham Linq  See test at jsPref    Comments    Here I put Value in square brackets  because VALUE is a keyword in SQL I have to use CAST   function to convert string Values to number type

User · Answer

ES6 reduce based version version with the support for function iteratee    Works just as expected if the iteratee function is not provided    x000D   x000D  const data     id  1  score  2   id  1  score  3   id  2  score  2   id  2  score  4   x000D   x000D  const group    arr  k    gt  arr reduce  r  c    gt   r c k         r c k          c   r        x000D   x000D  const groupBy    arr  k  fn        gt  true    gt   x000D    arr reduce  r  c    gt   fn c k     r c k         r c k          c    null  r        x000D   x000D  console log group data   id           grouping via  reduce  x000D  console log groupBy data   id         same result if  fn  is omitted x000D  console log groupBy data   score   x   gt  x  gt  2       group with the iteratee x000D   x000D   x000D    In the context of the OP question    x000D   x000D  const data       Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5       Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10       Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15       Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20       Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25       Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30       Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35       Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40      x000D   x000D  const groupBy    arr  k    gt  arr reduce  r  c    gt   r c k         r c k          c   r        x000D  const groupWith    arr  k  fn        gt  true    gt   x000D    arr reduce  r  c    gt   fn c k     r c k         r c k          c    null  r        x000D   x000D  console log groupBy data   Phase    x000D  console log groupWith data   Value   x   gt  x  gt  30        group by  Value   gt  30 x000D   x000D   x000D    Another ES6 version which reverses the grouping and uses the values as keys and the keys as the grouped values    x000D   x000D  const data     A   1     B   10     C   10    x000D   x000D  const groupKeys   arr   gt   x000D    arr reduce  r c    gt   Object keys c  map x   gt  r c x         r c x          x   r       x000D   x000D  console log groupKeys data   x000D   x000D   x000D    Note  functions are posted in their short form  one line  for brevity and to relate just the idea  You can expand them and add additional error checking etc

User · Answer

I have improved answers  This function takes array of group fields and return grouped object whom key is also object of group fields   function xs  groupFields            groupFields      concat groupFields           return xs reduce function rv  x                let groupKey   groupFields reduce  keyObject  field    gt                    keyObject field    x field                   return keyObject                                   rv JSON stringify groupKey     rv JSON stringify groupKey          push x               return rv                           let x            id  1       multimedia  false       language    tr             id  2       multimedia  false       language    fr             id  3       multimedia  true       language    tr             id  4       multimedia  false       language               id  5       multimedia  false       language    tr             id  6       multimedia  false       language    tr             id  7       multimedia  false       language    tr   fr        groupBy x    multimedia   language             multimedia  false  language    tr     Array 3        multimedia  false  language    fr     Array 1        multimedia  true  language    tr     Array 1        multimedia  false  language       Array 1        multimedia  false  language    tr   fr     Array 1

User · Answer

with ES6   const groupBy    items  key    gt  items reduce     result  item    gt            result       item key                result item key                 item

User · Answer

Ceasar s answer is good  but works only for inner properties of the elements inside the array  length in case of string    this implementation works more like  this link  const groupBy   function  arr  f        return arr reduce  out  val    gt            let by   typeof f      function         f val    val f            out by    out by         push val           return out                   hope this helps

User · Answer

You can build an ES6 Map from array reduce      const groupedMap   initialArray reduce       entryMap  e    gt  entryMap set e id      entryMap get e id       e        new Map        This has a few advantages over the other solutions     It doesn t require any libraries  unlike e g    groupBy    You get a JavaScript Map rather than an object  e g  as returned by   groupBy     This has lots of benefits  including    it remembers the order in which items were first added  keys can be any type rather than just strings    A Map is a more useful result that an array of arrays  But if you do want an array of arrays  you can then call Array from groupedMap entries     for an array of  key  group array  pairs  or Array from groupedMap values     for a simple array of arrays   It s quite flexible  often  whatever you were planning to do next with this map can be done directly as part of the reduction     As an example of the last point  imagine I have an array of objects that I want to do a  shallow  merge on by id  like this   const objsToMerge     id  1  name   Steve     id  2  name   Alice     id  1  age  20       The following variable should be created automatically const mergedArray     id  1  name   Steve   age  20    id  2  name   Alice      To do this  I would usually start by grouping by id  and then merging each of the resulting arrays  Instead  you can do the merge directly in the reduce     const mergedArray   Array from      objsToMerge reduce           entryMap  e    gt  entryMap set e id      entryMap get e id          e            new Map         values

User · Answer

x000D   x000D         array group by      category array     function arrayGroupBy     returns   object    fieldName                   static     author hht     param  string   key group key     param  array  data array        example example 01     --------------------------------------------------------------------------    import   arrayGroupBy   from   xx utils      const array                  type   assets         name   zhangsan         age   33                      type   config         name   a         age   13                      type   run         name   lisi         age   3                      type   xx         name   timo         age   4                  arrayGroupBy array  type           result         assets     age   33   name   zhangsan   type   assets            config     age   13   name   a   type   config            run     age   3   name   lisi   type   run            xx     age   4   name   timo   type   xx                    example example 02 null    --------------------------------------------------------------------------    const array   null     arrayGroupBy array  type          result           example example 03 key undefind    --------------------------------------------------------------------------    const array                  type   assets         name   zhangsan         age   33                      type   config         name   a         age   13                      type   run         name   lisi         age   3                      type   xx         name   timo         age   4                  arrayGroupBy array  xx                      const arrayGroupBy    data  key    gt      if   data     Array isArray data   return       const groupObj         data forEach  item    gt        if   item key   return      const fieldName   item key       if   groupObj fieldName           groupObj fieldName     item         return            groupObj fieldName  push item           return groupObj      const array                 type   assets         name   zhangsan         age   33                      type   config         name   a         age   13                      type   run         name   lisi         age   3                      type   run         name   wangmazi         age   3                      type   xx         name   timo         age   4               console dir arrayGroupBy array   type    x000D   lt p gt    describe  arrayGroupBy match        gt      const array                 type   assets         name   zhangsan         age   33                      type   config         name   a         age   13                      type   run         name   lisi         age   3                      type   xx         name   timo         age   4                  test  arrayGroupBy             gt        const result           assets     age   33   name   zhangsan   type   assets            config     age   13   name   a   type   config            run     age   3   name   lisi   type   run            xx     age   4   name   timo   type   xx                  expect arrayGroupBy array   type    toEqual result            test  arrayGroupBy not match          gt           result     expect arrayGroupBy array   xx    toEqual               test  arrayGroupBy null        gt        let array   null      expect arrayGroupBy array   type    toEqual               test  arrayGroupBy undefined        gt        let array   undefined      expect arrayGroupBy array   type    toEqual               test  arrayGroupBy empty        gt        let array           expect arrayGroupBy array   type    toEqual                  lt  p gt  x000D   x000D   x000D

User · Answer

Based on previous answers  const groupBy    prop    gt   xs    gt    xs reduce  rv  x    gt      Object assign rv    x prop         rv x prop           x            and it s a little nicer to look at with object spread syntax  if your environment supports   const groupBy    prop    gt   xs    gt    xs reduce  acc  x    gt            acc        x  prop            acc  x  prop             x                Here  our reducer takes the partially-formed return value  starting with an empty object   and returns an object composed of the spread out members of the previous return value  along with a new member whose key is calculated from the current iteree s value at prop and whose value is a list of all values for that prop along with the current value

User · Answer

Checked answer -- just shallow grouping  It s pretty nice to understand reducing  Question also provide the problem of additional aggregate calculations  Here is a REAL GROUP BY for Array of Objects by some field s  with 1  calculated key name and 2  complete solution for cascading of grouping by providing the list of the desired keys and converting its unique values to root keys like SQL GROUP BY does   x000D   x000D  const inputArray            Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5           Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10           Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15           Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20           Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25           Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30           Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35           Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40        var outObject   inputArray reduce function a  e         GROUP BY estimated key  estKey   well  may be a just plain key      a -- Accumulator result object      e -- sequentally checked Element  the Element that is tested just at this itaration       new grouping name may be calculated  but must be based on real value of real field   let estKey    e  Phase          a estKey    a estKey     a estKey    null         push e     return a           console log outObject   x000D   x000D   x000D   Play with estKey -- you may group by more then one field  add additional aggregations  calculations or other processing  Also you can groups data recursively  For example initially group by Phase  then by Step field and so on  Additionally blow off the fat rest data   x000D   x000D  const inputArray       Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5       Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10       Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15       Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20       Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25       Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30       Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35       Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40                 Small helper to get SHALLOW copy of obj WITHOUT prop     const rmProp    obj  prop    gt        prop        rest    gt rest  obj            Group Array by key  Root keys of a resulting array is value    of specified key         param       Array    src     The source array     param       String   key     The by key to group by     return      Object           Object with grouped objects as values     const grpBy    src  key    gt  src reduce  a  e    gt       a e key     a e key          push rmProp e  key     a                 Collapse array of object if it consists of only object with single value     Replace it by the rest value      const blowObj   obj   gt  Array isArray obj   amp  amp  obj length     1  amp  amp  Object values obj 0   length     1   Object values obj 0   0    obj          Recursive grouping with list of keys   keyList  may be an array    of key names or comma separated list of key names whom UNIQUE values will    becomes the keys of the resulting object      const grpByReal   function  src  keyList      const  key     rest    Array isArray keyList    keyList   String keyList  trim   split   s   s       const res   key   grpBy src  key        src     if  rest length    for  const k in res      res k    grpByReal res k   rest        else   for  const k in res      res k    blowObj res k           return res     console log  JSON stringify  grpByReal inputArray   Phase  Step  Task    null  2      x000D   x000D   x000D

User · Answer

Posting because even though this question is 7 years old  I have yet to see an answer that satisfies the original criteria      I don   t want them    split up    but    merged     more like the SQL group by   method    I originally came to this post because I wanted to find a method of reducing an array of objects  i e   the data structure created when you read from a csv  for example  and aggregate by given indices to produce the same data structure  The return value I was looking for was another array of objects  not a nested object or map like I ve seen proposed here    The following function takes a dataset  array of objects   a list of indices  array   and a reducer function  and returns the result of applying the reducer function on the indices as an array of objects   function agg data  indices  reducer          helper to create unique index as an array   function getUniqueIndexHash row  indices        return indices reduce  acc  curr    gt  acc   row curr                  reduce data to single object  whose values will be each of the new rows      structure is an object whose values are arrays           - gt            no operation performed  simply grouping   let groupedObj   data reduce  acc  curr    gt        let currIndex   getUniqueIndexHash curr  indices           if key does not exist  create array with current row     if   Object keys acc  includes currIndex           acc       acc   currIndex    curr          otherwise  extend the array at currIndex       else         acc       acc   currIndex   acc currIndex  concat curr               return acc                 reduce the array into a single object by applying the reducer   let reduced   Object values groupedObj  map arr   gt           for each sub-array  reduce into single object using the reducer function     let reduceValues   arr reduce reducer               reducer returns simply the aggregates - add in the indices here        each of the objects in  arr  has the same indices  so we take the first     let indexObj   indices reduce  acc  curr    gt          acc       acc   curr   arr 0  curr          return acc                   reduceValues       indexObj     reduceValues         return reduceValues            return reduced      I ll create a reducer that returns count    and sum Value    reducer    acc  curr    gt      acc count   1    acc count    0     acc value    curr Value    acc value   0     return acc      finally  applying the agg function with our reducer to the original dataset yields an array of objects with the appropriate aggregations applied   agg tasks    Phase    reducer      yields  Array 2      0  Object  Phase   Phase 1   count  4  value  50    1  Object  Phase   Phase 2   count  4  value  130     agg tasks    Phase    Step    reducer      yields  Array 4      0  Object  Phase   Phase 1   Step   Step 1   count  2  value  15    1  Object  Phase   Phase 1   Step   Step 2   count  2  value  35    2  Object  Phase   Phase 2   Step   Step 1   count  2  value  55    3  Object  Phase   Phase 2   Step   Step 2   count  2  value  75

User · Answer

Usually I use Lodash JavaScript utility library with a pre-built groupBy   method  It is pretty easy to use  see more details here

User · Answer

var arr            Phase   Phase 1    enter code here Step   Step 1   Task   Task 1   Value   5           Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10           Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15           Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20           Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25           Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30           Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35           Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40         Create and empty object  Loop through arr and add use Phase as unique key for obj  Keep updating total of key in obj while looping through arr   const obj       arr forEach  item    gt      obj item Phase    obj item Phase    obj item Phase       parseInt item Value    parseInt item Value         Result will look like this      Phase 1   50   Phase 2   130     Loop through obj to form and resultArr   const resultArr       for  item in obj      resultArr push   Phase  item  Value  obj item        console log resultArr

User · Answer

Array prototype groupBy   function keyFunction        var groups           this forEach function el            var key   keyFunction el           if  key in groups    false                groups key                          groups key  push el               return Object keys groups  map function key            return               key  key              values  groups key

User · Answer

Here is a ES6 version that won t break on null members  function groupBy  arr  key      return  arr        reduce  acc  x         gt            acc       x key        acc x key          x

User · Answer

A simple solution using ES6  The method has a return model and allows the comparison of n properties  const compareKey    item  key  compareItem    gt        return item key      compareItem key     const handleCountingRelatedItems    listItems  modelCallback  compareKeyCallback    gt        return listItems reduce  previousValue  currentValue    gt            if  Array isArray previousValue             const foundIndex   previousValue findIndex item   gt  compareKeyCallback item  currentValue            if  foundIndex  gt  -1                const count   previousValue foundIndex  count   1              previousValue foundIndex    modelCallback currentValue  count               return previousValue                    return     previousValue  modelCallback currentValue  1                      if  compareKeyCallback previousValue  currentValue             return  modelCallback currentValue  2                      return  modelCallback previousValue  1   modelCallback currentValue  1             const itemList           type   production   human readable   Production           type   test   human readable   Testing           type   production   human readable   Production       const model    currentParam  count    gt         label  currentParam human readable      type  currentParam type      count     const compareParameter    item  compareValue    gt        const isTypeEqual   compareKey item   type   compareValue      return isTypeEqual    const result   handleCountingRelatedItems itemList  model  compareParameter    console log  Result   n   result      Result                   label   Production   type   production   count  2              label   Testing   type   testing   count  1

User · Answer

let x               id    6        name    SMD L13        equipmentType            id    1          name    SMD                      id    7        name    SMD L15        equipmentType            id    1          name    SMD                      id    2        name    SMD L1        equipmentType            id    1          name    SMD                function groupBy array  property      return array reduce  accumulator  current    gt        const object property   current property       delete current property       let classified element   accumulator find x   gt  x id     object property id       let other elements   accumulator filter x   gt  x id     object property id       if  classified element         classified element children push current       else        classified element               object property           children    current                 return  classified element     other elements              console log  groupBy x   equipmentType         output              id    1        name    SMD        children                      id    6            name    SMD L13                            id    7            name    SMD L15                            id    2            name    SMD L1

User · Answer

You can use forEach on array and construct a new group of items  Here is how to do that with FlowType annotation      flow  export class Group lt T gt      tag  number   items  Array lt T gt     constructor         this items             const groupBy    items  Array lt T gt   map   T    gt  number    gt      const groups         let currentGroup   null    items forEach  item    gt        const tag   map item       if  currentGroup  amp  amp  currentGroup tag     tag          currentGroup items push item        else         const group   new Group lt T gt          group tag   tag       group items push item        groups push group         currentGroup   group               return groups    export default groupBy   A jest test can be like      flow  import groupBy from    groupBy   test  groupBy        gt      const items           name   January   month  0          name   February   month  1          name   February 2   month  1          const groups   groupBy items   item    gt        return item month         expect groups length  toBe 2    expect groups 1  items 1  name  toBe  February 2

User · Answer

I would check declarative-js groupBy it seems to do exactly what you are looking for  It is also     very performant  performance benchmark  written in typescript so all typpings are included  It is not enforcing to use 3rd party array-like objects    import   Reducers   from  declarative-js   import groupBy   Reducers groupBy  import Map   Reducers Map   const data           Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5           Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10           Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15           Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20           Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25           Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30           Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35           Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40        data reduce groupBy element  gt  element Step   Map     data reduce groupBy  Step    Map

User · Answer

var newArr   data reduce  acc  cur    gt        const existType   acc find a   gt  a Phase     cur Phase       if  existType            existType Value     cur Value          return acc             acc push           Phase  cur Phase          Value   cur Value             return acc

User · Answer

let groupbyKeys   function arr     keys      let keysFieldName   keys join      return arr map ele   gt        let keysField           keysField keysFieldName    keys reduce  keyValue  key    gt          return keyValue   ele key                  return Object assign     ele  keysField        reduce  groups  ele    gt         groups ele keysFieldName     groups ele keysFieldName                 push  ele  map e   gt            if  keys length  gt  1              delete e keysFieldName                     return e         0        return groups                console log groupbyKeys array   Phase     console log groupbyKeys array   Phase    Step     console log groupbyKeys array   Phase    Step    Task

User · Answer

I have expanded on the accepted answer to include grouping by multiple properties  add thenby and make it purely functional with no mutation  See a demo at https   stackblitz com edit typescript-ezydzv  export interface Group     key  any    items  any       export interface GroupBy     keys  string      thenby   GroupBy     export const groupBy    array  any    grouping  GroupBy   Group     gt      const keys   grouping keys    const groups   array reduce  groups  item    gt        const group   groups find g   gt  keys every key   gt  item key      g key key         const data   Object getOwnPropertyNames item         filter prop   gt   keys find key   gt  key     prop          reduce  o  key    gt        o   key   item key               return group         groups map g   gt   g     group        g  items      g items  data      g                          groups                          key  keys reduce  o  key    gt        o   key   item key                       items   data                                     return grouping thenby   groups map g   gt        g  items  groupBy g items  grouping thenby        groups

User · Answer

groupBy   tipo   A     tipo   A     tipo   B      tipo     gt  gt  Object  A  Array 2   B  Array 1     From  http   underscorejs org  groupBy

User · Answer

Imagine that you have something like this     id 1  cat  sedan    id 2  cat  sport    id 3  cat  sport    id 4  cat  sedan     By doing this  const categories        new Set cars map  car    gt  car cat     You will get this    sedan   sport    Explanation   1  First  we are creating a new Set by passing an array  Because Set only allows unique values  all duplicates will be removed    Now the duplicates are gone  we   re going to convert it back to an array by using the spread operator       Set Doc https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Set Spread OperatorDoc  https   developer mozilla org en-US docs Web JavaScript Reference Operators Spread syntax

User · Answer

Lets generate a generic Array prototype groupBy   tool  Just for variety let s use ES6 fanciness the spread operator for some Haskellesque pattern matching on a recursive approach  Also let s make our Array prototype groupBy   to accept a callback which takes the item  e  the index  i  and the applied array  a  as arguments    x000D   x000D  Array prototype groupBy   function cb   x000D                              return function iterate  x    xs   i   0  r             x000D                                       cb x i  x    xs      r 0  push x   r  x000D                                                            r 1  push x   r   x000D                                       return xs length   iterate xs    i  r    r  x000D                                       this   x000D                               x000D   x000D  var arr    0 1 2 3 4 5 6 7 8 9   x000D      res   arr groupBy e   gt  e  lt  5   x000D  console log res   x000D   x000D   x000D

User · Answer

groupByArray xs  key        return xs reduce function  rv  x            let v   key instanceof Function   key x    x key           let el   rv find  r    gt  r  amp  amp  r key     v           if  el                el values push x                     else               rv push                   key  v                  values   x                                    return rv                  This one outputs array

User · Answer

If you want to avoid external libraries  you can concisely implement a vanilla version of groupBy   like so   x000D   x000D  var groupBy   function xs  key      return xs reduce function rv  x         rv x key     rv x key          push x       return rv                console log groupBy   one    two    three     length           gt   3    one    two    5    three    x000D   x000D   x000D

User · Answer

Using ES6 Map object   x000D   x000D          description    Takes an Array lt V gt   and a grouping function     and returns a Map of the array grouped by the grouping function         param list An array of type V      param keyGetter A Function that takes the the Array type V as an input  and returns a value of type K                      K is generally intended to be a property key of V         returns Map of the array grouped by the grouping function        export function groupBy lt K  V gt  list  Array lt V gt   keyGetter   input  V    gt  K   Map lt K  Array lt V gt  gt          const map   new Map lt K  Array lt V gt  gt     function groupBy list  keyGetter        const map   new Map        list forEach  item    gt             const key   keyGetter item            const collection   map get key            if   collection                 map set key   item               else                collection push item                          return map         example usage  const pets          type  Dog   name  Spot         type  Cat   name  Tiger         type  Dog   name  Rover          type  Cat   name  Leo           const grouped   groupBy pets  pet   gt  pet type        console log grouped get  Dog        - gt    type  Dog   name  Spot     type  Dog   name  Rover    console log grouped get  Cat        - gt    type  Cat   name  Tiger     type  Cat   name  Leo     const odd   Symbol    const even   Symbol    const numbers    1 2 3 4 5 6 7    const oddEven   groupBy numbers  x   gt   x   2     1   odd   even         console log oddEven get odd       - gt   1 3 5 7  console log oddEven get even       - gt   2 4 6  x000D   x000D   x000D   About Map  https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Map

User · Answer

Without mutations   const groupBy    xs  key    gt  xs reduce  acc  x    gt  Object assign     acc       x key     acc x key          concat x           console log groupBy   one    two    three     length          gt   3    one    two    5    three

User · Answer

Below function allow to groupBy  and sum values - what OP need  of arbitrary fields  In solution we define cmp function to compare two object according to grouped fields  In let w     we create copy of subset object x fields  In y sumBy   y sumBy    x sumBy   we use     to cast string to number   function groupBy data  fields  sumBy  Value       let r     cmp   x y    gt  fields reduce  a b   gt  a  amp  amp  x b   y b   true     data forEach x  gt        let y r find z  gt cmp x z        let w      fields sumBy  reduce  a b    gt   a b  x b  a           y   y sumBy   y sumBy    x sumBy     r push w           return r       x000D   x000D  const d      x000D        Phase   Phase 1   Step   Step 1   Task   Task 1   Value   5     x000D        Phase   Phase 1   Step   Step 1   Task   Task 2   Value   10     x000D        Phase   Phase 1   Step   Step 2   Task   Task 1   Value   15     x000D        Phase   Phase 1   Step   Step 2   Task   Task 2   Value   20     x000D        Phase   Phase 2   Step   Step 1   Task   Task 1   Value   25     x000D        Phase   Phase 2   Step   Step 1   Task   Task 2   Value   30     x000D        Phase   Phase 2   Step   Step 2   Task   Task 1   Value   35     x000D        Phase   Phase 2   Step   Step 2   Task   Task 2   Value   40    x000D     x000D   x000D   x000D   x000D  function groupBy data  fields  sumBy  Value     x000D    let r     cmp   x y    gt  fields reduce  a b   gt  a  amp  amp  x b   y b   true   x000D    data forEach x  gt    x000D      let y r find z  gt cmp x z    x000D      let w      fields sumBy  reduce  a b    gt   a b  x b  a       x000D      y   y sumBy   y sumBy    x sumBy     r push w   x000D        x000D    return r  x000D    x000D   x000D   x000D     TEST x000D  let p  t o    gt  console log t  JSON stringify o    x000D  console log  GROUP BY     x000D   x000D  p  Phase   groupBy d   Phase       x000D  p  Step   groupBy d   Step       x000D  p  Phase-Step   groupBy d   Phase    Step       x000D  p  Phase-Task   groupBy d   Phase    Task       x000D  p  Step-Task   groupBy d   Step    Task       x000D  p  Phase-Step-Task   groupBy d   Phase   Step    Task       x000D   x000D   x000D

User · Answer

This solution takes any arbitrary function  not a key  so it s more flexible than solutions above  and allows arrow functions  which are similar to lambda expressions used in LINQ   Array prototype groupBy   function  funcProp        return this reduce function  acc  val             acc funcProp val     acc funcProp val          push val           return acc                   NOTE  whether you want to extend Array s prototype is up to you   Example supported in most browsers     a 1 b  b    a 1 c  c    a 2 d  d    groupBy function c  return c a      Example using arrow functions  ES6      a 1 b  b    a 1 c  c    a 2 d  d    groupBy c  gt c a    Both examples above return        1      a   1   b    b      a   1   c    c        2      a   2   d    d

User · Answer

MDN has this example in their Array reduce   documentation       Grouping objects by a property    https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Array Reduce Grouping objects by a property Grouping objects by a property  var people         name   Alice   age  21        name   Max   age  20        name   Jane   age  20       function groupBy objectArray  property      return objectArray reduce function  acc  obj        var key   obj property       if   acc key           acc key                  acc key  push obj       return acc               var groupedPeople   groupBy people   age       groupedPeople is             20             name   Max   age  20              name   Jane   age  20                 21     name   Alice   age  21

User · Answer

This is probably more easily done with linq js  which is intended to be a true implementation of LINQ in JavaScript  DEMO    var linq   Enumerable From data   var result       linq GroupBy function x   return x Phase              Select function x             return               Phase  x Key                Value  x Sum function y   return y Value 0                             ToArray      result           Phase   Phase 1   Value  50          Phase   Phase 2   Value  130       Or  more simply using the string-based selectors  DEMO    linq GroupBy    Phase            k e   gt    Phase k  Value e Sum    Value 0       ToArray

User · Answer

Here s a nasty  hard to read solution using ES6  export default  arr  key    gt     arr reduce       r  v         k   v key     gt    r k      r k         push v   r                For those asking how does this even work  here s an explanation   In both   gt  you have a free return  The Array prototype reduce function takes up to 4 parameters  That s why a fifth parameter is being added so we can have a cheap variable declaration for the group  k  at the parameter declaration level by using a default value   yes  this is sorcery   If our current group doesn t exist on the previous iteration  we create a new empty array   r k      r k         This will evaluate to the leftmost expression  in other words  an existing array or an empty array  this is why there s an immediate push after that expression  because either way you will get an array   When there s a return  the comma   operator will discard the leftmost value  returning the tweaked previous group for this scenario    An easier to understand version that does the same is  export default  array  key    gt     array reduce  previous  currentItem    gt        const group   currentItem key       if   previous group   previous group            previous group  push currentItem       return previous             Edit  TS Version  const groupBy    lt T  K extends keyof any gt  list  T    getKey   item  T    gt  K    gt    list reduce  previous  currentItem    gt        const group   getKey currentItem       if   previous group   previous group            previous group  push currentItem       return previous          as Record lt K  T   gt

User · Answer

i d like to suggest my approach  First  separate grouping and aggregating  Lets declare prototypical  group by  function  It takes another function to produce  hash  string for each array element to group by    Array prototype groupBy   function hash     var  hash   hash   hash   function o  return o       var  map         var put   function map  key  value       if   map  hash key              map  hash key                 map  hash key   group               map  hash key   key   key             map  hash key   group push value           this map function obj       put  map  obj  obj            return Object keys  map  map function key       return  key   map key  key  group   map key  group             when grouping is done you can aggregate data how you need  in your case  data groupBy function o  return JSON stringify  a  o Phase  b  o Step             aggreagating         map function el             var sum   el group reduce             function l c                return l   parseInt c Value                            0                      el key Value   sum            return el key            in common it works  i have tested this code in chrome console  and feel free to improve and find mistakes

User · Answer

Based on the original idea of  Ceasar Bautista  i modified the code and created a groupBy function using typescript   static groupBy data  any    comparator   v1  any  v2  any    gt  boolean  onDublicate   uniqueRow  any  dublicateRow  any    gt  void        return data reduce function  reducedRows  currentlyReducedRow          let processedRow   reducedRows find searchedRow   gt  comparator searchedRow  currentlyReducedRow           if  processedRow               currentlyReducedRow is a dublicateRow when processedRow is not null          onDublicate processedRow  currentlyReducedRow          else              currentlyReducedRow is unique and must be pushed in the reducedRows collection          reducedRows push currentlyReducedRow                  return reducedRows                     This function accepts a callback  comparator  that compares the rows and finds the dublicates and a second callback  onDublicate  that aggregates the dublicates   usage example   data           name   a   value  10          name   a   value  11          name   a   value  12          name   b   value  20          name   b   value  1          private static demoComparator    v1  any  v2  any    gt        return v1  name       v2  name           private static demoOnDublicate    uniqueRow  dublicateRow    gt        uniqueRow  value      dublicateRow  value               calling   groupBy data  demoComparator  demoOnDublicate     will perform a group by that calculates the sum of value    name   a   value  33   name   b   value  21    We can create as many of these callback functions as required by the project and aggregate the values as necessary  In one case for example i needed to merge two arrays instead of summing the data

User · Answer

I would check lodash groupBy it seems to do exactly what you are looking for  It is also quite lightweight and really simple   Fiddle example  https   jsfiddle net r7szvt5k   Provided that your array name is arr the groupBy with lodash is just   import groupBy from  lodash groupBy      if you still use require     const groupBy   require  lodash groupBy     const a   groupBy arr  function n      return n Phase         a is your array grouped by Phase attribute

[javascript] Most efficient method to groupby on an array of objects

Examples related to javascript

Examples related to arrays

Examples related to object

Examples related to group-by

Examples related to underscore.js