How to check if two arrays are equal with JavaScript

Question

var a    1  2  3   var b    3  2  1   var c   new Array 1  2  3    alert a    b         b    c     demo  How can I check these array for equality and get a method which returns true if they are equal   Does jQuery offer any method for this

User · Answer

Check every each value by a for loop once you checked the size of the array   function equalArray a  b        if  a length     b length            for  var i   0  i  lt  a length  i                  if  a i      b i                     return false                                  return true        else           return false

User · Answer

Even if this would seem super simple  sometimes it s really useful  If all you need is to see if two arrays have the same items and they are in the same order  try this    1  2  3  toString       1  2  3  toString   true  1  2  3   toString       1  2  3  toString   true  1 2 3  toString       1  2  3  toString   true   However  this doesn t work for mode advanced cases such as     1 2   3   toString        1   2 3   toString   true   It depends what you need

User · Answer

2021 changelog  bugfix for option4  no total ordering on js objects  even excluding NaN  NaN and  5   5   5    5   2  lt 3  etc     so cannot use  sort on Map keys    though you can on Object keys obj   since even  numerical  keys are strings   Option 1 Easiest option  works in almost all cases  except that null   undefined but they both are converted to JSON representation null and considered equal  function arraysEqual a1 a2           WARNING  arrays must not contain  objects  or behavior may be undefined        return JSON stringify a1   JSON stringify a2       This might not work if your array contains objects  Whether this still works with objects depends on whether the JSON implementation sorts keys  For example  the JSON of  1 2 3 4  may or may not be equal to  3 4 1 2   this depends on the implementation  and the spec makes no guarantee whatsoever   2017 update  Actually the ES6 specification now guarantees object keys will be iterated in order of 1  integer properties  2  properties in the order they were defined  then 3  symbol properties in the order they were defined  Thus IF the JSON stringify implementation follows this  equal objects  in the     sense but NOT NECESSARILY in the    sense  will stringify to equal values  More research needed  So I guess you could make an evil clone of an object with properties in the reverse order  but I cannot imagine it ever happening by accident     At least on Chrome  the JSON stringify function tends to return keys in the order they were defined  at least that I ve noticed   but this behavior is very much subject to change at any point and should not be relied upon  If you choose not to use objects in your lists  this should work fine  If you do have objects in your list that all have a unique id  you can do a1 map function x   return  id x uniqueId     If you have arbitrary objects in your list  you can read on for option  2   This works for nested arrays as well  It is  however  slightly inefficient because of the overhead of creating these strings and garbage-collecting them   Option 2 More  quot proper quot  option  which you can override to deal with special cases  like regular objects and null undefined and custom objects  if you so desire      generally useful functions function type x       does not work in general  but works on JSONable objects we care about    modify as you see fit        e g   type  asdf g  -- gt   quot  object RegExp  quot      return Object prototype toString call x     function zip arrays           e g  zip   1 2 3   4 5 6    -- gt    1 4   2 5   3 6       return arrays 0  map function   i           return arrays map function array  return array i                     helper functions function allCompareEqual array           e g   allCompareEqual  2 2 2 2   -- gt  true        does not work with nested arrays or objects     return array every function x  return x  array 0        function isArray x   return type x   type       function getLength x   return x length   function allTrue array   return array reduce function a b  return a amp  amp b  true           e g  allTrue  true true true true   -- gt  true        or just array every function x  return x        function allDeepEqual things           works with nested arrays     if  things every isArray            return allCompareEqual things map getLength          all arrays of same length                 amp  amp  allTrue zip things  map allDeepEqual       elements recursively equal        else if  this every isObject            return  all have exactly same keys  and for                  each key k  allDeepEqual  o1 k  o2 k                 e g       amp  amp  allTrue objectZip objects  map allDeepEqual           else if                extend some more      else         return allCompareEqual things      Demo  allDeepEqual                 true allDeepEqual    1    1    1     true allDeepEqual    1 2    1 2     true allDeepEqual     1 2   3      1 2   3      true  allDeepEqual    1 2 3    1 2 3 4     false allDeepEqual     1 2   3      1 2     3     false allDeepEqual     1 2   3      1   2 3      false allDeepEqual     1 2  3    1  2 3      false  To use this like a regular function  do  function allDeepEqual2         return allDeepEqual    slice call arguments       Demo  allDeepEqual2   1 2  3     1 2  3   true   Options 3 edit  It s 2016 and my previous overcomplicated answer was bugging me  This recursive  imperative  quot recursive programming 101 quot  implementation keeps the code really simple  and furthermore fails at the earliest possible point  giving us efficiency   It also doesn t generate superfluous ephemeral datastructures  not that there s anything wrong with functional programming in general  but just keeping it clean here   If we wanted to apply this to a non-empty arrays of arrays  we could do seriesOfArrays reduce arraysEqual   This is its own function  as opposed to using Object defineProperties to attach to Array prototype  since that would fail with a key error if we passed in an undefined value  that is however a fine design decision if you want to do so   This only answers OPs original question  function arraysEqual a b                   Array-aware equality checker          Returns whether arguments a and b are    to each other          however if they are equal-lengthed arrays  returns whether their          elements are pairwise    to each other recursively under this         definition             if  a instanceof Array  amp  amp  b instanceof Array            if  a length  b length      assert same length             return false          for var i 0  i lt a length  i        assert each element equal             if   arraysEqual a i  b i                    return false          return true        else           return a  b      if not both arrays  should be the same          Examples  arraysEqual   1 2  3     1 2  3   true arraysEqual  1 2 3    1 2 3 4   false arraysEqual   1 2   3      1 2     3   false arraysEqual   1 2   3      1   2 3    false arraysEqual   1 2  3   undefined  false arraysEqual undefined  undefined  true arraysEqual 1  2  false arraysEqual null  null  true arraysEqual 1  1  true arraysEqual     1  false arraysEqual     undefined  false arraysEqual         true  If you wanted to apply this to JSON-like data structures with js Objects  you could do so  Fortunately we re guaranteed that all objects keys are unique  so iterate over the objects OwnProperties and sort them by key  then assert that both the sorted key-array is equal and the value-array are equal  and just recurse  We can extend this to include Maps as well  where the keys are also unique    However if we extend this to Sets  we run into the tree isomorphism problem http   logic pdmi ras ru  smal files smal jass08 slides pdf - fortunately it s not as hard as general graph isomorphism  there is in fact an O  vertices  algorithm to solve it  but it can get very complicated to do it efficiently  The pathological case is if you have a set made up of lots of seemingly-indistinguishable objects  but upon further inspection some of those objects may differ as you delve deeper into them  You can also work around this by using hashing to reject almost all cases    Option 4   continuation of 2016 edit  This should work with most objects  const STRICT EQUALITY    a b   gt  a   b  function deepEquals a b  areEqual STRICT EQUALITY           compares objects hierarchically using the provided         notion of equality  defaulting to              supports Arrays  Objects  Maps  ArrayBuffers        if  a instanceof Array  amp  amp  b instanceof Array          return arraysEqual a b  areEqual       if  Object getPrototypeOf a    Object prototype  amp  amp  Object getPrototypeOf b    Object prototype          return objectsEqual a b  areEqual       if  a instanceof Map  amp  amp  b instanceof Map          return mapsEqual a b  areEqual               if  a instanceof Set  amp  amp  b instanceof Set            if  areEquals   STRICT EQUALITY              return setsEqual a b           else             throw  quot Error  set equality by hashing not implemented because cannot guarantee custom notion of equality is transitive without programmer intervention  quot            if   a instanceof ArrayBuffer    ArrayBuffer isView a    amp  amp   b instanceof ArrayBuffer    ArrayBuffer isView b            return typedArraysEqual a b       return areEqual a b       see note 1  -- IMPORTANT    function arraysEqual a b  areEqual        if  a length  b length          return false      for var i 0  i lt a length  i            if   deepEquals a i  b i   areEqual               return false      return true    function objectsEqual a b  areEqual        var aKeys   Object getOwnPropertyNames a       var bKeys   Object getOwnPropertyNames b       if  aKeys length  bKeys length          return false      aKeys sort        bKeys sort        for var i 0  i lt aKeys length  i            if   areEqual aKeys i  bKeys i       keys must be strings             return false      return deepEquals aKeys map k  gt a k    aKeys map k  gt b k    areEqual     function mapsEqual a b  areEqual       assumes Map s keys use the       notion of equality  which is also the assumption of  has and  get methods in the spec  however  Map s values use our notion of the areEqual parameter     if  a size  b size          return false      return     a keys    every k  gt           b has k   amp  amp  deepEquals a get k   b get k   areEqual           function setsEqual a b           see discussion in below rest of StackOverflow answer     return a size  b size  amp  amp      a keys    every k  gt           b has k           function typedArraysEqual a b           we use the obvious notion of equality for binary data     a   new Uint8Array a       b   new Uint8Array b       if  a length    b length          return false      for var i 0  i lt a length  i            if  a i   b i               return false      return true     Demo  not extensively tested   var nineTen   new Float32Array 2   nineTen 0  9  nineTen 1  10    gt  deepEquals        1  2 3    4   a 5  111  6   new Map    c  7    d  8     nineTen         1  2 3    4   111 6 a 5   new Map    d  8    c  7     nineTen    true   gt  deepEquals        1  2 3    4   a  5   111  6   new Map    c  7    d  8     nineTen         1  2 3    4   111 6 a 5   new Map    d  8    c  7     nineTen        a b   gt a  b   true  Note that if one is using the    notion of equality  then know that falsey values and coercion means that    equality is NOT TRANSITIVE  For example     0 and 0   0  but      0   This is relevant for Sets  I do not think one can override the notion of Set equality in a meaningful way  If one is using the built-in notion of Set equality  that is        then the above should work  However if one uses a non-transitive notion of equality like     you open a can of worms  Even if you forced the user to define a hash function on the domain  hash a   hash b  implies a  b  I m not sure that would help    Certainly one could do the O N 2  performance thing and remove pairs of    items one by one like a bubble sort  and then do a second O N 2  pass to confirm things in equivalence classes are actually    to each other  and also    to everything not thus paired  but you d STILL have to throw a runtime error if you have some coercion going on    You d also maybe get weird  but potentially not that weird  edge cases with https   developer mozilla org en-US docs Glossary Falsy and Truthy values  with the exception that NaN  NaN    but just for Sets    This is not an issue usually with most Sets of homogenous datatype   sidenote  Maps are es6 dictionaries  I can t tell if they have O 1  or O log N   lookup performance  but in any case they are  ordered  in the sense that they keep track of the order in which key-value pairs were inserted into them  However  the semantic of whether two Maps should be equal if elements were inserted in a different order into them is ambiguous  I give a sample implementation below of a deepEquals that considers two maps equal even if elements were inserted into them in a different order    note  1   IMPORTANT  NOTION OF EQUALITY  You may want to override the noted line with a custom notion of equality  which you ll also have to change in the other functions anywhere it appears  For example  do you or don t you want NaN  NaN  By default this is not the case  There are even more weird things like 0   0   Do you consider two objects to be the same if and only if they are the same object in memory  See https   stackoverflow com a 5447170 711085   You should document the notion of equality you use    You should be able to extend the above to WeakMaps  WeakSets  Not sure if it makes sense to extend to DataViews  Should also be able to extend to RegExps probably  etc  As you extend it  you realize you do lots of unnecessary comparisons  This is where the type function that I defined way earlier  solution  2  can come in handy  then you can dispatch instantly  Whether that is worth the overhead of  possibly  not sure how it works under the hood  string representing the type is up to you  You can just then rewrite the dispatcher  i e  the function deepEquals  to be something like  var dispatchTypeEquals         number  function a b      a  b          array  function a b      deepEquals x y                 function deepEquals a b        var typeA   extractType a       var typeB   extractType a       return typeA  typeB  amp  amp  dispatchTypeEquals typeA  a b

User · Answer

Based on Tim James answer and Fox32 s comment  the following should check for nulls  with the assumption that two nulls are not equal   function arrays equal a b    return   a  amp  amp    b  amp  amp    a lt b    b lt a       gt  arrays equal  1 2 3    1 3 4   false  gt  arrays equal  1 2 3    1 2 3   true  gt  arrays equal  1 3 4    1 2 3   false  gt  arrays equal null   1 2 3   false  gt  arrays equal null  null  false

User · Answer

For primitive values like numbers and strings this is an easy solution   a    1 2 3   b    3 2 1   a sort   toString      b sort   toString      The call to sort   will ensure that the order of the elements does not matter  The toString   call will create a string with the values comma separated so both strings can be tested for equality

User · Answer

jQuery has such method for deep recursive comparison   A homegrown general purpose strict equality check could look as follows   function deepEquals obj1  obj2  parents1  parents2         use strict       var i         compare null and undefined     if  obj1     undefined    obj2     undefined             obj1     null    obj2     null            return obj1     obj2                compare primitives     if  typeof  obj1       object     typeof  obj2       object             return obj1 valueOf       obj2 valueOf                  if objects are of different types or lengths they can t be equal     if  obj1 constructor     obj2 constructor     obj1 length     undefined  amp  amp  obj1 length     obj2 length             return false                iterate the objects     for  i in obj1               build the parents list for object on the left  obj1          if  parents1     undefined  parents1               if  obj1 constructor     Object  parents1 push obj1              build the parents list for object on the right  obj2          if  parents2     undefined  parents2               if  obj2 constructor     Object  parents2 push obj2              walk through object properties         if  obj1 propertyIsEnumerable i                 if  obj2 propertyIsEnumerable i                        if object at i was met while going down here                    it s a self reference                 if   obj1 i  constructor     Object  amp  amp  parents1 indexOf obj1 i    gt   0      obj2 i  constructor     Object  amp  amp  parents2 indexOf obj2 i    gt   0                         if  obj1 i      obj2 i                             return false                                            continue                                       it s not a self reference so we are here                 if   deepEquals obj1 i   obj2 i   parents1  parents2                         return false                                  else                      obj2 i  does not exist                 return false                                    return true       Tests      message is displayed on failure    clean console     all tests passed function assertTrue cond  msg        if   cond            console log msg            var a    sdf       b    sdf   assertTrue deepEquals b  a    Strings are equal     b    dfs   assertTrue  deepEquals b  a    Strings are not equal     a   9  b   9  assertTrue deepEquals b  a    Numbers are equal     b   3  assertTrue  deepEquals b  a    Numbers are not equal     a   false  b   false  assertTrue deepEquals b  a    Booleans are equal     b   true  assertTrue  deepEquals b  a    Booleans are not equal     a   null  assertTrue  deepEquals b  a    Boolean is not equal to null     a   function          return true     assertTrue deepEquals         1  1  1        2   asdf    1  a         3             a   1 0            true             1  1  1        2   asdf    1  a         3             a   1 0            true       Arrays are equal     assertTrue  deepEquals         1  1  1        2   asdf    1  a         3             a   1 0            true            1  1  1        2   asdf    1  a         3             a    1             true       Arrays are not equal     a         prop   val     a self   a  b         prop   val     b self   a  assertTrue deepEquals b  a    Immediate self referencing objects are equal     a prop    shmal   assertTrue  deepEquals b  a    Immediate self referencing objects are not equal     a         prop   val       inside        a inside self   a  b         prop   val       inside        b inside self   a  assertTrue deepEquals b  a    Deep self referencing objects are equal     b inside self   b  assertTrue  deepEquals b  a    Deep self referencing objects are not equeal  Not the same instance     b inside self    foo   bar    assertTrue  deepEquals b  a    Deep self referencing objects are not equal  Completely different object     a       b       a self   a  b self       assertTrue  deepEquals b  a    Empty object and self reference of an empty object

User · Answer

If you are using lodash and don t want to modify either array  you can use the function   xor     It compares the two arrays as sets and returns the set that contains their difference   If the length of this difference is zero  the two arrays are essentially equal   var a    1  2  3   var b    3  2  1   var c   new Array 1  2  3     xor a  b  length     0 true   xor b  c  length     0 true

User · Answer

There is no easy way to do this  I needed this as well  but wanted a function that can take any two variables and test for equality  That includes non-object values  objects  arrays and any level of nesting    In your question  you mention wanting to ignore the order of the values in an array  My solution doesn t inherently do that  but you can achieve it by sorting the arrays before comparing for equality  I also wanted the option of casting non-objects to strings so that  1 2      1  2   Since my project uses UnderscoreJs  I decided to make it a mixin rather than a standalone function    You can test it out on http   jsfiddle net nemesarial T44W4   Here is my mxin     mixin           Tests for the equality of two variables     valA  first variable     valB  second variable     stringifyStatics  cast non-objects to string so that  1    1         equal function valA valB stringifyStatics       stringifyStatics   stringifyStatics         check for same type     if typeof valA    typeof valB          if    isObject valA       isObject valB             return false                       test non-objects for equality     if    isObject valA          if stringifyStatics           var valAs    valA          var valBs    valB          ret     valA        valB          else          ret valA   valB                return ret               test for length     if   size valA     size valB          return false               test for arrays first     var isArr   isArray valA          test whether both are array or both object     if isArr     isArray valB          return false             var ret true      if isArr           do test for arrays         each valA function val idx lst           if  ret  return           ret ret  amp  amp    equal val valB idx  stringifyStatics                  else          do test for objects         each valA function val idx lst           if  ret  return              test for object member exists         if    has valB idx              ret false            return                        test for member equality         ret ret  amp  amp    equal val valB idx  stringifyStatics                        return ret            This is how you use it     equal  1 2 3   1 2  3   true    To demonstrate nesting  you can do this     equal        a   b  b  c    someId  1  2    1 2 3          a   b  b  c    someId   1   2     1   2  3    true

User · Answer

jQuery does not have a method for comparing arrays  However the Underscore library  or the comparable Lodash library  does have such a method  isEqual  and it can handle a variety of other cases  like object literals  as well  To stick to the provided example   var a  1 2 3   var b  3 2 1   var c new Array 1 2 3    alert   isEqual a  b            isEqual b  c      By the way  Underscore has lots of other methods that jQuery is missing as well  so it s a great complement to jQuery   EDIT  As has been pointed out in the comments  the above now only works if both arrays have their elements in the same order  ie      isEqual  1 2 3    1 2 3       true   isEqual  1 2 3    3 2 1       false   Fortunately Javascript has a built in method for for solving this exact problem  sort     isEqual  1 2 3  sort     3 2 1  sort        true

User · Answer

Using map   and reduce     function arraysEqual  a1  a2        return a1     a2              a1     null  amp  amp  a2     null  amp  amp          a1 length     a2 length  amp  amp          a1              map function  val  idx    return val     a2 idx                   reduce function  prev  cur    return prev  amp  amp  cur     true

User · Answer

This is what you should do  Please do not use stringify nor  lt   gt    function arraysEqual a  b      if  a     b  return true    if  a    null    b    null  return false    if  a length     b length  return false        If you don t care about the order of the elements inside      the array  you should sort both arrays here       Please note that calling sort on an array will modify that array       you might want to clone your array first     for  var i   0  i  lt  a length    i        if  a i      b i   return false        return true

User · Answer

var a   1  2  3   3    var b    1  2  3    var c   a filter function  i    return    b indexOf i        alert c length

User · Answer

It handle all possible stuff and even reference itself in structure of object  You can see the example at the end of code   var deepCompare    function         function internalDeepCompare  obj1  obj2  objects            var i  objPair           if  obj1     obj2                return true                     i   objects length          while  i--                objPair   objects i               if     objPair obj1     obj1  amp  amp  objPair obj2     obj2                        objPair obj1     obj2  amp  amp  objPair obj2     obj1                                                 return true                                                      objects push  obj1  obj1  obj2  obj2             if  obj1 instanceof Array                if    obj2 instanceof Array                     return false                             i   obj1 length               if  i     obj2 length                   return false                              while  i--                    if   internalDeepCompare obj1 i   obj2 i   objects                         return false                                                    else               switch  typeof obj1                    case  object                                          deal with null                     if    obj2  amp  amp  obj1 constructor     obj2 constructor                             return false                                             if  obj1 instanceof RegExp                            if    obj2 instanceof RegExp  amp  amp  obj1 source     obj2 source                                 return false                                                                                       else if  obj1 instanceof Date                            if    obj2 instanceof Date  amp  amp  obj1 getTime       obj2 getTime                                   return false                                                                       else                               for  i in obj1                                if  obj1 hasOwnProperty i                                            if    obj2 hasOwnProperty i   amp  amp  internalDeepCompare obj1 i   obj2 i   objects                                          return false                                                                                                                                               break                  case  function                        if    typeof obj2      function   amp  amp  obj1        obj2                                return false                                            break                  default                    deal with NaN                      if  obj1     obj2  amp  amp  obj1     obj1  amp  amp  obj2     obj2                            return false                                                                     return true             return function  obj1  obj2            return internalDeepCompare obj1  obj2                                var a    a  undefined  new Date 10          a 2   function      Infinity  -Infinity  NaN  0  -0  1   4 5    1    -1    a   null       b    b  undefined  new Date 10          a 2   function      Infinity  -Infinity  NaN  0  -0  1   4 5    1    -1    a   null   deepCompare a  b

User · Answer

With JavaScript version 1 6 it s as easy as this   Array prototype equals   function  array       return this length    array length  amp  amp            this every  function this i i    return this i    array i              For example     equals     gives true  while  1 2 3  equals   1 3 2    yields false

User · Answer

If you wish to check arrays of objects for equality and order does NOT matter  i e    areEqual   id   0     id   1       id   1     id   0        true  you ll want to sort the arrays first  lodash has all the tools you ll need  by combining sortBy and isEqual      arr1  amp  arr2  Arrays of objects     sortProperty  the property of the object with which you want to sort    Note  ensure every object in both arrays has your chosen sortProperty    For example  arr1     id   v-test id0     id   v-test id1       and          arr2     id   v-test id1     id   v-test id0       sortProperty should be  id   function areEqual  arr1  arr2  sortProperty      return   areEqual   sortBy arr1  sortProperty     sortBy arr2  sortProperty       EDIT  Since sortBy returns a new array  there is no need to clone your arrays before sorting  The original arrays will not be mutated   Note that for lodash s isEqual  order does matter  The above example will return false if sortBy is not applied to each array first

User · Answer

This method sucks  but I ve left it here for reference so others avoid this path     Using Option 1 from  ninjagecko worked best for me   Array prototype equals   function array        return array instanceof Array  amp  amp  JSON stringify this      JSON stringify array       a    1   2  3   a equals   1  2   3      false a equals  1   2  3       true   It will also handle the null and undefined case  since we re adding this to the prototype of array and checking that the other argument is also an array

[javascript] How to check if two arrays are equal with JavaScript?

Examples related to javascript