Comparing Arrays of Objects in JavaScript

Question

I want to compare 2 arrays of objects in JavaScript code   The objects have 8 total properties  but each object will not have a value for each  and the arrays are never going to be any larger than 8 items each  so maybe the brute force method of traversing each and then looking at the values of the 8 properties is the easiest way to do what I want to do  but before implementing  I wanted to see if anyone had a more elegant solution  Any thoughts

User · Answer

I know this is an old question and the answers provided work fine     but this is a bit shorter and doesn t require any additional libraries   i e  JSON     function arraysAreEqual ary1 ary2     return  ary1 join        ary2 join

User · Answer

Here is my attempt  using Node s assert module   npm package object-hash   I suppose that you would like to check if two arrays contain the same objects  even if those objects are ordered differently between the two arrays   var assert   require  assert    var hash   require  object-hash     var obj1    a  1  b  2  c  333       obj2    b  2  a  1  c  444       obj3    b   AAA   c  555       obj4    c  555  b   AAA     var array1    obj1  obj2  obj3  obj4   var array2    obj3  obj2  obj4  obj1       obj3  obj3  obj2  obj1  should work as well     calling assert deepEquals array1  array2  at this point FAILS  throws an AssertionError     even if array1 and array2 contain the same objects in different order     because array1 0  c     array2 0  c     sort objects in arrays by their hashes  so that if the arrays are identical     their objects can be compared in the same order  one by one var array1   sortArrayOnHash array1   var array2   sortArrayOnHash array2       then  this should output  PASS  try       assert deepEqual array1  array2       console log  PASS      catch  e        console log  FAIL        console log e         You could define as well something like Array prototype sortOnHash      function sortArrayOnHash array        return array sort function a  b            return hash a   gt  hash b

User · Answer

I tried JSON stringify   and worked for me   let array1    1 2  value  alpha      array2     value  alpha    music  3 4    JSON stringify array1       1 2   value   alpha      JSON stringify array2         value   alpha    music  3 4    JSON stringify array1      JSON stringify array2      false

User · Answer

The objectsAreSame function mentioned in  JasonBunting s answer works fine for me  However  there s a little problem  If x propertyName  and y propertyName  are objects  typeof x propertyName      object    you ll need to call the function recursively in order to compare them

User · Answer

There s my solution  It will compare arrays which also have objects and arrays  Elements can be stay in any positions  Example  const array1     a  1    b  2     c  0  d    e  1  f  2        1 2 3 54    const array2     a  1    b  2     c  0  d    e  1  f  2        1 2 3 54     const arraysCompare    a1  a2    gt      if  a1 length     a2 length  return false    const objectIteration    object    gt        const result           const objectReduce    obj    gt          for  let i in obj            if  typeof obj i       object               result push    i   obj i                else             objectReduce obj i                                 objectReduce object       return result         const reduceArray1   a1 map item   gt        if  typeof item      object   return item      return objectIteration item  join              const reduceArray2   a2 map item   gt        if  typeof item      object   return item      return objectIteration item  join              const compare    reduceArray1 map item   gt  reduceArray2 includes item      return compare reduce  acc  item    gt  acc   Number item       a1 length      console log arraysCompare array1  array2

User · Answer

comparing with json is pretty bad  try this package to compare nested arrays and get the difference   https   www npmjs com package deep-object-diff

User · Answer

EDIT  You cannot overload operators in current  common browser-based implementations of JavaScript interpreters   To answer the original question  one way you could do this  and mind you  this is a bit of a hack  simply serialize the two arrays to JSON and then compare the two JSON strings  That would simply tell you if the arrays are different  obviously you could do this to each of the objects within the arrays as well to see which ones were different   Another option is to use a library which has some nice facilities for comparing objects - I use and recommend MochiKit     EDIT  The answer kamens gave deserves consideration as well  since a single function to compare two given objects would be much smaller than any library to do what I suggest  although my suggestion would certainly work well enough    Here is a na  ve implemenation that may do just enough for you - be aware that there are potential problems with this implementation   function objectsAreSame x  y       var objectsAreSame   true     for var propertyName in x          if x propertyName      y propertyName              objectsAreSame   false           break                  return objectsAreSame      The assumption is that both objects have the same exact list of properties   Oh  and it is probably obvious that  for better or worse  I belong to the only-one-return-point camp

User · Answer

Please try this one   function used to compare two arrays a  b         This block will make the array of indexed that array b contains a elements   var c   a filter function value  index  obj        return b indexOf value   gt  -1              This is used for making comparison that both have same length if no condition go wrong    if  c length     a length        return 0      else      return 1

User · Answer

As serialization doesn t work generally  only when the order of properties matches  JSON stringify  a 1 b 2       JSON stringify  b 2 a 1    you have to check the count of properties and compare each property as well    x000D   x000D  const objectsEqual    o1  o2    gt  x000D      Object keys o1  length     Object keys o2  length  x000D           amp  amp  Object keys o1  every p   gt  o1 p      o2 p    x000D   x000D  const obj1     name   John   age  33   x000D  const obj2     age  33  name   John     x000D  const obj3     name   John   age  45    x000D           x000D  console log objectsEqual obj1  obj2       true x000D  console log objectsEqual obj1  obj3       false x000D   x000D   x000D    If you need a deep comparison  you can call the function recursively    x000D   x000D  const obj1     name   John   age  33  info    married  true  hobbies    sport    art        x000D  const obj2     age  33  name   John   info    hobbies    sport    art    married  true      x000D  const obj3     name   John   age  33    x000D   x000D  const objectsEqual    o1  o2    gt   x000D      typeof o1      object   amp  amp  Object keys o1  length  gt  0  x000D            Object keys o1  length     Object keys o2  length  x000D               amp  amp  Object keys o1  every p   gt  objectsEqual o1 p   o2 p    x000D            o1     o2  x000D           x000D  console log objectsEqual obj1  obj2       true x000D  console log objectsEqual obj1  obj3       false x000D   x000D   x000D    Then it s easy to use this function to compare objects in arrays   const arr1    obj1  obj1   const arr2    obj1  obj2   const arr3    obj1  obj3    const arraysEqual    a1  a2    gt      a1 length     a2 length  amp  amp  a1 every  o  idx    gt  objectsEqual o  a2 idx      console log arraysEqual arr1  arr2       true console log arraysEqual arr1  arr3       false

User · Answer

using   some from lodash  https   lodash com docs 4 17 11 some  const array1AndArray2NotEqual                some array1   a1  idx    gt  a1 key1     array2 idx  key1                                          a1 key2     array2 idx  key2                                          a1 key3     array2 idx  key3

User · Answer

Honestly  with 8 objects max and 8 properties max per object  your best bet is to just traverse each object and make the comparisons directly   It ll be fast and it ll be easy   If you re going to be using these types of comparisons often  then I agree with Jason about JSON serialization   but otherwise there s no need to slow down your app with a new library or JSON serialization code

User · Answer

I have worked a bit on a simple algorithm to compare contents of two objects and return an intelligible list of difference  Thought I would share  It borrows some ideas for jQuery  namely the map function implementation and the object and array type checking    It returns a list of  diff objects   which are arrays with the diff info  It s very simple   Here it is       compare contents of two objects and return a list of differences    returns an array where each element is also an array in the form      accessor  diffType  leftValue  rightValue         diffType is one of the following       value  when primitive values at that index are different      undefined  when values in that index exist in one object but don t in                  another  one of the values is always undefined      null  when a value in that index is null or undefined  values are            expressed as boolean values  indicated wheter they were nulls      type  when values in that index are of different types  values are             expressed as types      length  when arrays in that index are of different length  values are              the lengths of the arrays     function DiffObjects o1  o2           choose a map   impl         you may use   map from jQuery if you wish     var map   Array prototype map          function a    return Array prototype map apply a  Array prototype slice call arguments  1                function a  f                 var ret   new Array a length   value              for   var i   0  length   a length  i  lt  length  i                      ret i    f a i   i               return ret concat                       shorthand for push impl      var push   Array prototype push          check for null undefined values     if   o1    null      o2    null             if  o1    o2              return        null   o1  null  o2  null             return undefined     both null              compare types     if   o1 constructor    o2 constructor              typeof o1    typeof o2             return        type   Object prototype toString call o1   Object prototype toString call o2         different type                compare arrays     if  Object prototype toString call o1       object Array              if  o1 length    o2 length                 return        length   o1 length  o2 length       different length                   var diff              for  var i 0  i lt o1 length  i                     per element nested diff             var innerDiff   DiffObjects o1 i   o2 i                if  innerDiff       o1 i     o2 i                     merge diff array into parent s while including parent object name   i                   push apply diff  map innerDiff  function o  j    o 0        i         o 0   return o                                          if any differences were found  return them         if  diff length              return diff             return nothing if arrays equal         return undefined                compare object trees     if  Object prototype toString call o1       object Object              var diff                 check all props in o1         for  var prop in o1                   the double check in o1 is because in V8 objects remember keys set to undefined              if   typeof o2 prop      undefined    amp  amp   typeof o1 prop      undefined                         prop exists in o1 but not in o2                 diff push        prop         undefined   o1 prop   undefined       prop exists in o1 but not in o2                            else                      per element nested diff                 var innerDiff   DiffObjects o1 prop   o2 prop                    if  innerDiff       o1 prop     o2 prop                         merge diff array into parent s while including parent object name   prop                       push apply diff  map innerDiff  function o  j    o 0        prop         o 0   return o                                                          for  var prop in o2                   the double check in o2 is because in V8 objects remember keys set to undefined              if   typeof o1 prop      undefined    amp  amp   typeof o2 prop      undefined                         prop exists in o2 but not in o1                 diff push        prop         undefined   undefined  o2 prop        prop exists in o2 but not in o1                                     if any differences were found  return them         if  diff length              return diff             return nothing if objects equal         return undefined               if same type and not null or objects or arrays        perform primitive value comparison     if  o1    o2          return        value   o1  o2            return nothing if values are equal     return undefined

User · Answer

There is a optimized code for case when function needs to equals to empty arrays  and returning false in that case  const objectsEqual    o1  o2    gt        if  o2     null  amp  amp  o1     null  return false      return o1     null  amp  amp  typeof o1      object   amp  amp  Object keys o1  length  gt  0           Object keys o1  length     Object keys o2  length  amp  amp           Object keys o1  every p   gt  objectsEqual o1 p   o2 p               o1     null  amp  amp  Array isArray o1   amp  amp  Array isArray o2   amp  amp   o1 length  amp  amp            o2 length    true   o1     o2

[javascript] Comparing Arrays of Objects in JavaScript

Examples related to javascript

Examples related to arrays

Examples related to comparison