How to compare arrays in JavaScript

Question

I d like to compare two arrays    ideally  efficiently  Nothing fancy  just true if they are identical  and false if not  Not surprisingly  the comparison operator doesn t seem to work   var a1    1 2 3   var a2    1 2 3   console log a1  a2         Returns false console log JSON stringify a1   JSON stringify a2          Returns true   JSON encoding each array does  but is there a faster or  better  way to simply compare arrays without having to iterate through each value

User · Answer

I think the simplest way is to turn each array into a string like you tried, and compare the strings.

To convert the arrays into string, just put this string of methods onto the arrays. These are the arrays:

var arr1 = [1, 2, "foo", 3, "bar", 3.14]
var arr2 = [1, 2, "foo", 3, "bar", 3.14]

Now, you have to convert them into the strings. The list of methods are:

arr1.toString().replace(/,/gi, "")
arr2.toString().replace(/,/gi, "")

The methods do:

**.toString()** -

Turns array into a string, concatenating the elements of the array.

Ex. ["tree", "black hole"] -> "tree,black hole"

Sadly, it includes the commas. That is why we have to do:

***.replace(a, b)***

It finds and replaces the first argument (a) with the second argument (b) in the string you are doing it on.

Ex.

"0000010000010000000".replace("1", "2")

will return: "0000020000010000000"

It only replaces the first instance of parameter 1, so we can do regex instead.

Ex.

"0000010000010000000".replace(/1/gi, "2")

will return: "0000020000020000000"

You wrap what you want to replace with /. Say what you want to replace is 1. You make it: /1/. But then you have to add the gi at the end so that it selects every instance. So, you have to put /1/gi with a comma at the end, and then you can put what you want to replace it with.

Now, your two arrays are:

arr1: "12foo3bar3.14" arr2: "12foo3bar3.14"

Now you say this:

if(arr1 === arr2) {
  // Now the code you put inside of this if statement will only run if arr1 and arr2 have the same contents.
} else {
  // This code will run if arr1 and arr2 have any differences.
}

If you want to check if arr1 CONTAINS arr2 instead of having the same exact contents, you do this.

if(arr1.indexOf(arr2) !== -1) {
    //This code will happen if arr2 is inside of arr1. If there is one extra array 
    //item in arr1, it doesn't matter. But, if arr2 has an extra array item, nothing in 
    //this if will run. If you want arr2 to contain arr1, just make arr1 in the 
    //condition of this if arr2, and make arr2 arr1.
}

Basically, if you want the arrays to be the EXACT SAME, do this:

if(arr1.toString().replace(/,/gi, "") === arr2.toString().replace(/,/gi, "")) {
    //arrays are the same
} else {
    //arrays are different
}

And if you want to know if an array contains another, just do this:

arrayThatWillHoldAnotherArray = arrayThatWillHoldAnotherArray.toString().replace(/,/gi)
arrayThatWillBeInsideAnotherArray = arrayThatWillBeInsideAnotherArray.toString().replace(/,/gi)


if(arrayThatWillHoldAnotherArray.indexOf(arrayThatWillBeInsideAnotherArray) !== -1) {
    //arrayThatWillHoldAnotherArray has arrayThatWillBeInsideAnotherArray inside of it
} else {
    //it doesn't
}

_x000D_

console.log("Read the code to understand this.")
var arr1 = [1,2,"foo",3,"bar",3.14]
var arr2 = [1,2,"foo",3,"bar",3.14]
function checkIfArraysAreTheSame(a,b) {
  if(a.toString().replace(/,/gi,"") === b.toString().replace(/,/gi,"")) {
    console.log("A and B are the same!")
    return true;
  }
  console.log("A and B are NOT the same!")
  return false
}
checkIfArraysAreTheSame(arr1,arr2)
//expected output: A and B are the same!
//Now, let's add another item to arr2.
arr2.push("Lorem")
checkIfArraysAreTheSame(arr1,arr2)
//expected output: A and B are NOT the same!

function checkIfArrayIsNestedInsideAnother(a,b) {
  //If this returns true, b is nested inside a.
  if (a.toString().replace(/,/gi,"").indexOf(b.toString().replace(/,/gi,"")) > -1) {
    console.log("B is nested inside of A!")
  } else if(b.toString().replace(/,/gi,"").indexOf(a.toString().replace(/,/gi,"")) > -1) {
    console.log("A is nested inside of B!")
  }
}

checkIfArrayIsNestedInsideAnother(arr1, arr2)
//expected output: A is nested inside of B! because:
//arr1 (a): [1,2,"foo",3,"bar",3.14]
//arr2 (b): [1,2,"foo",3,"bar",3.14, "Lorem"]
//We added Lorem at line 15.

//Now, let's check if arr2 is nested inside arr1, which it is not.
checkIfArrayIsNestedInsideAnother(arr2, arr1)
//expected output: B is nested inside of A!

_x000D_

User · Answer

JSON stringify collectionNames  includes JSON stringify sourceNames      array push collection i     null   This is how i did it

User · Answer

I quite like this approach in that it is substantially more succinct than others  It essentially contrasts all items to an accumulator which maintains a same value which is replaced with NaN if it reaches one that is distinct  As NaN cannot be equal to any value  including NaN itself  the value would be converted into a boolean      and be false  Otherwise  the value should be true  To prevent an array of zeros to return false  the expression is converted to its absolute value and added to 1  thus    Math abs 0    1  would be true  The absolute value was added for the case -1  which  when added to 1 would be equal to 0 and so  false   function areArrayItemsEqual arr        return    Math abs arr reduce  a  b    gt  a     b   b   NaN     1

User · Answer

Shortest For an array of numbers try  a1     a2   x000D   x000D  var a1    1 2 3   var a2    1 2 3    console log  a1     a2   x000D   x000D   x000D   Note  this method will not work when the array also contains strings  e g  a2    1   quot 2 3 quot

User · Answer

In the spirit of the original question      I d like to compare two arrays    ideally  efficiently  Nothing   fancy  just true if they are identical  and false if not    I have been running performance tests on some of the more simple suggestions proposed here with the following results  fast to slow    while  67   by Tim Down  var i   a1 length  while  i--        if  a1 i      a2 i   return false    return true   every  69   by user2782196  a1 every  v i   gt  v     a2 i      reduce  74   by DEIs  a1 reduce  a  b    gt  a  amp  amp  a2 includes b   true     join  amp  toString  78   by Gaizka Allende  amp  vivek  a1 join         a2 join       a1 toString       a2 toString      half toString  90   by Victor Palomo  a1    a2 toString      stringify  100   by radtek  JSON stringify a1      JSON stringify a2        Note the examples below assumes the arrays are sorted  single-dimensional arrays   length comparison has been removed for a common benchmark  add a1 length     a2 length to any of the suggestions and you will get a  10  performance boost   Choose whatever solutions that works best for you knowing the speed and limitation of each       Unrelated note  it is interesting to see people getting all trigger-happy John Waynes on the down vote button on perfectly legitimate answers to this question

User · Answer

Your code will not handle the case appropriately when both arrays have same elements but not in same order   Have a look at my code with your example which compares two arrays whose elements are numbers  you might modify or extend it for other element types  by utilising  join   instead of  toString       x000D   x000D  var a1    1 2 3   x000D  var a2    1 2 3   x000D  const arraysAreEqual   a1 sort   toString    a2 sort   toString    x000D     true if both arrays have same elements else false x000D  console log arraysAreEqual   x000D   x000D   x000D

User · Answer

Building off Tom     Zato s answer  I agree that just iterating through the arrays is the fastest   Additionally  like others have already stated   the function should be called equals equal  not compare   In light of this  I modified the function to handle comparing arrays for similarity - i e  they have the same elements  but out of order - for personal use  and thought I d throw it on here for everyone to see   Array prototype equals   function  array  strict        if   array          return false       if  arguments length    1          strict   true       if  this length    array length          return false       for  var i   0  i  lt  this length  i              if  this i  instanceof Array  amp  amp  array i  instanceof Array                if   this i  equals array i   strict                   return false                    else if  strict  amp  amp  this i     array i                 return false                    else if   strict                return this sort   equals array sort    true                       return true      This function takes an additional parameter of strict that defaults to true   This strict parameter defines if the arrays need to be wholly equal in both contents and the order of those contents  or simply just contain the same contents   Example   var arr1    1  2  3  4   var arr2    2  1  4  3       Loosely equal to 1 var arr3    2  2  3  4       Not equal to 1 var arr4    1  2  3  4       Strictly equal to 1  arr1 equals arr2              false arr1 equals arr2  false       true arr1 equals arr3              false arr1 equals arr3  false       false arr1 equals arr4              true arr1 equals arr4  false       true   I ve also written up a quick jsfiddle with the function and this example  http   jsfiddle net Roundaround DLkxX

User · Answer

If you want to compare two arrays and check if any object is same in both arrays it will works  Example    Array1    a b c d  Array2    d e f g   Here   d  is common in both array so this function will return true value    cehckArray array1  array2        for  let i   0  i  lt  array1 length  i            for  let j   0  j  lt  array2 length  j              if  array1 i      array2 j               return true                                 Return if no common element exist      return false

User · Answer

Herer s my solution          Tests two data structures for equality     param  object  x     param  object  y     returns  boolean      var equal   function x  y        if  typeof x     typeof y  return false      if  x instanceof Array  amp  amp  y instanceof Array  amp  amp  x length     y length  return false      if  typeof x      object             for  var p in x  if  x hasOwnProperty p                 if  typeof x p       function   amp  amp  typeof y p       function   continue              if  x p  instanceof Array  amp  amp  y p  instanceof Array  amp  amp  x p  length     y p  length  return false              if  typeof x p      typeof y p   return false              if  typeof x p       object   amp  amp  typeof y p       object     if   equal x p   y p    return false    else             if  x p      y p   return false                  else return x     y      return true       Works with any nested data structure  and obviously ignores objects  methods  Don t even think of extending Object prototype with this method  when I tried this once  jQuery broke     For most arrays it s still faster than most of serialization solutions  It s probably the fastest compare method for arrays of object records

User · Answer

While this only works for scalar arrays  see note below   it is short  array1 length     array2 length  amp  amp  array1 every function value  index    return value     array2 index     Rr  in ECMAScript 6   CoffeeScript   TypeScript with Arrow Functions  array1 length     array2 length  amp  amp  array1 every  value  index    gt  value     array2 index     Note   scalar  here means values that can be compared directly using       So  numbers  strings  objects by reference  functions by reference  See the MDN reference for more info about the comparison operators   UPDATE From what I read from the comments  sorting the array and comparing may give accurate result  const array2Sorted   array2 slice   sort    array1 length     array2 length  amp  amp  array1 slice   sort   every function value  index        return value     array2Sorted index        Eg  array1    2 3 1 4   array2    1 2 3 4    Then the above code would give true

User · Answer

Even though this has a lot of answers  one that I believe to be of help   const newArray        new Set      arr1     arr2        It is not stated in the question how the structure of the array is going to look like  so If you know for sure that you won t have nested arrays nor objects in you array  it happened to me  that s why I came to this answer  the above code will work   What happens is that we use spread operator         to concat both arrays  then we use Set to eliminate any duplicates  Once you have that you can compare their sizes  if all three arrays have the same size you are good to go   This answer also ignores the order of elements  as I said  the exact situation happened to me  so maybe someone in the same situation might end up here  as I did      Edit1   Answering Dmitry Grinko s question   Why did you use spread operator         here -    new Set   It doesn t work   Consider this code   const arr1      a    b    const arr2      a    b    c    const newArray     new Set      arr1     arr2      console log newArray    You ll get    Set    a    b    c        In order to work with that value you d need to use some Set properties  see https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Set   On the other hand  when you use this code   const arr1      a    b    const arr2      a    b    c    const newArray        new Set      arr1     arr2      console log newArray    You ll get     a    b    c      That s the difference  the former would give me a Set  it would work too as I could get the size of that Set  but the latter gives me the array I need  what s more direct to the resolution

User · Answer

R  cursive cmp function working with number string array object   x000D   x000D   lt script gt  x000D  var cmp   function element  target   x000D   x000D     if typeof element     typeof target  x000D       x000D        return false  x000D       x000D     else if typeof element      object   amp  amp    target     element   x000D       x000D        return target     element  x000D       x000D     else if typeof element      object   x000D       x000D         var keys element   Object keys element   x000D         var keys target    Object keys target   x000D          x000D         if keys element length     keys target length  x000D           x000D             return false  x000D           x000D         else x000D           x000D             for var i   0  i  lt  keys element length  i    x000D               x000D                  if keys element i      keys target i   x000D                      return false  x000D                  if  cmp element keys element i    target keys target i     x000D                      return false  x000D               x000D       return true  x000D           x000D       x000D     else x000D       x000D         return element     target  x000D   x000D       x000D     x000D   x000D  console log cmp   x000D      key1  3  x000D      key2   string   x000D      key3   4   45    key4   5   6   false  null   v 1     x000D       x000D      key1  3  x000D      key2   string   x000D      key3   4   45    key4   5   6   false  null   v 1     x000D          true x000D   x000D  console log cmp   x000D      key1  3  x000D      key2   string   x000D      key3   4   45    key4   5   6   false  null   v 1     x000D       x000D      key1  3  x000D      key2   string   x000D      key3   4   45    key4   5   6   undefined  null   v 1     x000D          false x000D   lt  script gt  x000D   x000D   x000D

User · Answer

While the top answer to this question is correct and good  the code provided could use some improvement   Below is my own code for comparing arrays and objects   The code is short and simple   Array prototype equals   function otherArray      if   otherArray    this length    otherArray length  return false    return this reduce function equal  item  index        var otherItem   otherArray index       var itemType   typeof item  otherItemType   typeof otherItem      if  itemType     otherItemType  return false      return equal  amp  amp   itemType      object    item equals otherItem    item     otherItem        true       if  Object prototype keys      Object prototype keys   function         var a           for  var key in this          if  this hasOwnProperty key   a push key             return a        Object defineProperty Object prototype   keys    enumerable  false       Object prototype equals   function otherObject      if   otherObject  return false    var object   this  objectKeys   object keys      if   objectKeys equals otherObject keys     return false    return objectKeys reduce function equal  key        var value   object key   otherValue   otherObject key       var valueType   typeof value  otherValueType   typeof otherValue      if  valueType     otherValueType  return false         this will call Array prototype equals for arrays and Object prototype equals for objects     return equal  amp  amp   valueType      object    value equals otherValue    value     otherValue        true     Object defineProperty Object prototype   equals    enumerable  false      This code supports arrays nested in objects and objects nested in arrays   You can see a full suite of tests and test the code yourself at this repl  https   repl it Esfz 3

User · Answer

Additionally  I have converted Thomas  solution to order free comparison as I needed    Array prototype equalsFreeOrder   function  array        var isThisElemExist      if   array          return false       if  this length    array length          return false       for  var i   0  i  lt  this length  i              isThisElemExist   false          for  var k   0  k  lt  this length  k                  if  this i  instanceof Array  amp  amp  array k  instanceof Array                    if  this i  equalsFreeOrder array k                        isThisElemExist   true                            else if  this i     array k                     isThisElemExist   true                                  if   isThisElemExist              return false            return true

User · Answer

There is a Stage 1 proposal  introduced in 2020  to allow for the easy comparison of arrays by adding Array prototype equals to the language  This is how it would work  without any libraries  monkeypatching  or any other code   1  2  3  equals  1  2  3      evaluates to true  1  2  undefined  equals  1  2  3      evaluates to false  1   2   3  4    equals  1   2   3  4        evaluates to true  It s only a tentative proposal so far - TC39 will now  quot devote time to examining the problem space  solutions and cross-cutting concerns quot   If it makes it to stage 2  it has a good chance of eventually being integrated into the language proper

User · Answer

How about using  includes  with  forEach       var array1    1 2 3       var array2    1 2 4       var array diff   0         loop through each element in first array     array1 forEach function elem              check if second array contains it  return false if not         if  array2 includes elem                array diff   1              return false           else              array diff   0                           loop through each element in second array     array2 forEach function elem              check if first array contains it  return false if not         if  array1 includes elem                array diff   1              return false           else              array diff   0                           variable array diff determines the result     if array diff    1           alert  Arrays are different         else          alert  Arrays are same           Note  This should work on both sorted and unsorted arrays

User · Answer

function palindrome text         var Res1   new Array        var Res2   new Array        for  i   0  i  lt  text length  i                         Res1 i    text substr i  1                       j 0  for  k    text length-1   k gt  0  k--                       Res2 j    text substr k  1                   j j 1                      if JSON stringify Res1   JSON stringify Res2            return true       else          return false           document write palindrome  katak

User · Answer

Here is a very short way to do it  function arrEquals arr1  arr2        return arr1 length    arr2 length  amp  amp        arr1 filter elt  gt arr1 filter e  gt e   elt  length    arr2 filter e  gt e   elt  length  length    arr1 length

User · Answer

An alternative way using filter and arrow functions  arrOne length     arrTwo length  amp  amp  arrOne filter  currVal  idx    gt  currVal     arrTwo idx   length     0

User · Answer

It s a tricky implicit array equality checking but can handle the job right after coherence arrays to string  var a1    1  2  3   var a2    1  2  3   var isEqual   a1  lt   a2  amp  amp  a1  gt   a2     true

User · Answer

function compareArrays arrayA  arrayB        if  arrayA length    arrayB length  return true      for  i   0  i  lt  arrayA length  i            if  arrayB indexOf arrayA i      -1                return true                      for  i   0  i  lt  arrayB length  i              if  arrayA indexOf arrayB i      -1                return true                      return false

User · Answer

To compare arrays  loop through them and compare every value  Comparing arrays     Warn if overriding existing method if Array prototype equals      console warn  quot Overriding existing Array prototype equals  Possible causes  New API defines the method  there s a framework conflict or you ve got double inclusions in your code  quot       attach the  equals method to Array s prototype to call it on any array Array prototype equals   function  array           if the other array is a falsy value  return     if   array          return false          compare lengths - can save a lot of time      if  this length    array length          return false       for  var i   0  l this length  i  lt  l  i                 Check if we have nested arrays         if  this i  instanceof Array  amp  amp  array i  instanceof Array                   recurse into the nested arrays             if   this i  equals array i                    return false                                      else if  this i     array i                     Warning - two different object instances will never be equal   x 20      x 20              return false                                           return true       Hide method from for-in loops Object defineProperty Array prototype   quot equals quot    enumerable  false     Usage   1  2   3  4   equals  1  2   3  2        false   1   quot 2 3 quot   equals  1  2  3       false   1  2   3  4   equals  1  2   3  4        true   1  2  1  2  equals  1  2  1  2       true   You may say  quot But it is much faster to compare strings - no loops    quot  well  then you should note there ARE loops  First recursive loop that converts Array to string and second  that compares two strings  So this method is faster than use of string  I believe that larger amounts of data should be always stored in arrays  not in objects  However if you use objects  they can be partially compared too  Here s how  Comparing objects  I ve stated above  that two object instances will never be equal  even if they contain same data at the moment    a 1  foo  quot bar quot   numberOfTheBeast  666        a 1  foo  quot bar quot   numberOfTheBeast  666      false  This has a reason  since there may be  for example private variables within objects  However  if you just use object structure to contain data  comparing is still possible  Object prototype equals   function object2          For the first loop  we only check for types     for  propName in this              Check for inherited methods and properties - like  equals itself           https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Object hasOwnProperty           Return false if the return value is different         if  this hasOwnProperty propName     object2 hasOwnProperty propName                 return false                      Check instance type         else if  typeof this propName     typeof object2 propName                   Different types   gt  not equal             return false                        Now a deeper check using other objects property names     for propName in object2              We must check instances anyway  there may be a property that only exists in object2               I wonder  if remembering the checked values from the first loop would be faster or not          if  this hasOwnProperty propName     object2 hasOwnProperty propName                 return false                    else if  typeof this propName     typeof object2 propName                 return false                      If the property is inherited  do not check any more  it must be equa if both objects inherit it          if  this hasOwnProperty propName             continue                     Now the detail check and recursion                    This returns the script back to the array comparing            REQUIRES Array equals            if  this propName  instanceof Array  amp  amp  object2 propName  instanceof Array                          recurse into the nested arrays            if   this propName  equals object2 propName                            return false                    else if  this propName  instanceof Object  amp  amp  object2 propName  instanceof Object                          recurse into another objects                      console log  quot Recursing to compare  quot   this propName   quot with quot  object2 propName    quot  both named   quot  quot  propName  quot   quot  quot               if   this propName  equals object2 propName                            return false                      Normal value comparison for strings and numbers         else if this propName     object2 propName                return false                        If everything passed  let s say YES     return true       However  remember that this one is to serve in comparing JSON like data  not class instances and other stuff  If you want to compare mor complicated objects  look at this answer and it s superlong function  To make this work with Array equals you must edit the original function a little bit             Check if we have nested arrays     if  this i  instanceof Array  amp  amp  array i  instanceof Array               recurse into the nested arrays         if   this i  equals array i                return false               REQUIRES OBJECT COMPARE        else if  this i  instanceof Object  amp  amp  array i  instanceof Object               recurse into another objects           console log  quot Recursing to compare  quot   this propName   quot with quot  object2 propName    quot  both named   quot  quot  propName  quot   quot  quot            if   this i  equals array i                return false                else if  this i     array i          I made a little test tool for both of the functions  Bonus  Nested arrays with indexOf and contains Samy Bencherif has prepared useful functions for the case you re searching for a specific object in nested arrays  which are available here  https   jsfiddle net SamyBencherif 8352y6yw

User · Answer

Extending Tom     Zato idea  Tomas s Array prototype compare should be infact called  Array prototype compareIdentical   It passes on    1  2   3  4   compareIdentical   1  2   3  2        false   1   2 3   compareIdentical   1  2  3       false   1  2   3  4   compareIdentical   1  2   3  4        true   1  2  1  2  compareIdentical   1  2  1  2       true    But fails on     1  2   3  2   1  2   3  2   compareIdentical  1  2   3  2   1  2   3  2       Here is better  in my opinion  version   Array prototype compare   function  array           if the other array is a falsy value  return     if   array          return false          compare lengths - can save a lot of time     if  this length    array length          return false       this sort        array sort        for  var i   0  i  lt  this length  i                 Check if we have nested arrays         if  this i  instanceof Array  amp  amp  array i  instanceof Array                   recurse into the nested arrays             if   this i  compare array i                    return false                    else if  this i     array i                    Warning - two different object instances will never be equal   x 20      x 20              return false                      return true      http   jsfiddle net igos bcfCY

User · Answer

On the same lines as JSON encode is to use join     function checkArrays  arrA  arrB           check if lengths are different     if arrA length     arrB length  return false          slice so we do not effect the original       sort makes sure they are in order       join makes it a string so we can do a string compare     var cA   arrA slice   sort   join            var cB   arrB slice   sort   join            return cA   cB      var a    1 2 3 4 5   var b    5 4 3 2 1   var c    1 2 3 4   var d    1 2 3 4 6   var e     1   2   3   4   5       will return true  console log  checkArrays a b        true console log  checkArrays a c        false console log  checkArrays a d        false console log  checkArrays a e        true   Only problem is if you care about types which the last comparison tests  If you care about types  you will have to loop   function checkArrays  arrA  arrB           check if lengths are different     if arrA length     arrB length  return false         slice so we do not effect the orginal       sort makes sure they are in order     var cA   arrA slice   sort         var cB   arrB slice   sort         for var i 0 i lt cA length i              if cA i    cB i   return false             return true      var a    1 2 3 4 5   var b    5 4 3 2 1   var c    1 2 3 4   var d    1 2 3 4 6   var e     1   2   3   4   5     console log  checkArrays a b        true console log  checkArrays a c        false console log  checkArrays a d        false console log  checkArrays a e        false   If the order should remain the same  than it is just a loop  no sort is needed   function checkArrays  arrA  arrB           check if lengths are different     if arrA length     arrB length  return false        for var i 0 i lt arrA length i              if arrA i    arrB i   return false             return true      var a    1 2 3 4 5   var b    5 4 3 2 1   var c    1 2 3 4   var d    1 2 3 4 6   var e     1   2   3   4   5     console log  checkArrays a a        true console log  checkArrays a b        false console log  checkArrays a c        false console log  checkArrays a d        false console log  checkArrays a e        false

User · Answer

I needed something similar  comparing two arrays containing identifiers but in random order  In my case   does this array contain at least one identifier from the other list   The code is quite simple  using the reduce-function    function hasFullOverlap listA  listB       return listA reduce  allIdsAreFound   id    gt                We return true until an ID has not been found in the other list           return listB includes  id   amp  amp  allIdsAreFound             true      if hasFullOverlap listA  listB   amp  amp  hasFullOverlap listB  listA          Both lists contain all the values

User · Answer

Recursive  amp  works on NESTED arrays   function ArrEQ a1 a2      return              Are both elements arrays          Array isArray a1  amp  amp Array isArray a2                        Yes  Test each entry for equality          a1 every  v i   gt  ArrEQ v a2 i                          No  Simple Comparison           a1   a2              console log   Works With Nested Arrays      console log  ArrEQ        1 2 3  4 5  6  SAME IDENTICAL           1 2 3  4 5  6  SAME IDENTICAL               console log  ArrEQ        1 2 3  4 5  6  DIFFERENT APPLES            1 2 3  4 5  6  DIFFERENT ORANGES

User · Answer

let equals    LHS  RHS    gt        if    LHS instanceof Array   return  false  gt  L H S is t an array       if    RHS instanceof Array   return  false  gt  R H S is t an array       if  LHS length    RHS length  return false      let to string   x   gt  JSON stringify x sort  a  b    gt  a - b        return to string LHS     to string RHS         let l   console log l equals  5 3 2   3 2 5          true l equals  3 2 5 3   3 2 5        false

User · Answer

It s unclear what you mean by  identical   For example  are the arrays a and b below identical  note the nested arrays    var a     foo     bar     b     foo     bar       Here s an optimized array comparison function that compares corresponding elements of each array in turn using strict equality and does not do recursive comparison of array elements that are themselves arrays  meaning that for the above example  arraysIdentical a  b  would return false  It works in the general case  which JSON- and join  -based solutions will not   function arraysIdentical a  b        var i   a length      if  i    b length  return false      while  i--            if  a i      b i   return false            return true

User · Answer

Works with MULTIPLE arguments with NESTED arrays      Return true if all of the arrays equal     Works with nested arrays  function AllArrEQ    arrays       for var i   0  i  lt   arrays length-1   i              var a1   arrays i 0           var a2   arrays i 1           var res                    Are both elements arrays              Array isArray a1  amp  amp Array isArray a2                                Yes  Compare Each Sub-Array                 v  a1 i              a1 every  v i   gt  AllArrEQ v a2 i                                  No  Simple Comparison               a1   a2                      if  res  return false               return  true         console log  AllArrEQ            1 2 3  4 5  6  ALL EQUAL                  1 2 3  4 5  6  ALL EQUAL                  1 2 3  4 5  6  ALL EQUAL                  1 2 3  4 5  6  ALL EQUAL

User · Answer

Comparing 2 arrays   var arr1    1 2 3   var arr2    1 2 3    function compare arr1 arr2      if  arr1    arr2   amp  amp   arr1 length    arr2 length       return true    else     return false      calling function  var isBool   compare arr1 sort   join   arr2 sort   join

User · Answer

Here a possibility for unsorted arrays and custom comparison      const array1    1 3 2 4 5       const array2    1 3 2 4 5            const isInArray1   array1 every item   gt  array2 find item2   gt  item   item2       const isInArray2   array2 every item   gt  array1 find item2   gt  item   item2            const isSameArray   array1 length     array2 length  amp  amp  isInArray1  amp  amp  isInArray2          console log isSameArray     true

User · Answer

If you are using a testing framework like Mocha with the Chai assertion library  you can use deep equality to compare arrays   expect a1  to deep equal a2    This should return true only if the arrays have equal elements at corresponding indices

User · Answer

I know that JSON stringfy is slow when dealing with large datasets but what if you used template literals   Example   const a    1  2  3   const b    1  2   test     const a string   Array isArray a   amp  amp     a    const b string   Array isArray b   amp  amp     b     const result    a     b    console log result     Taking into consideration you re using ES6 of course

User · Answer

The Practical Way  I think it s wrong to say a particular implementation is  The Right Way     if it s only  right    correct   in contrast to a  wrong  solution  Tom     s solution is a clear improvement over string-based array comparison  but that doesn t mean it s objectively  right   What is right anyway  Is it the fastest  Is it the most flexible  Is it the easiest to comprehend  Is it the quickest to debug  Does it use the least operations  Does it have any side effects  No one solution can have the best of all the things   Tom     s could say his solution is fast but I would also say it is needlessly complicated  It tries to be an all-in-one solution that works for all arrays  nested or not  In fact  it even accepts more than just arrays as an input and still attempts to give a  valid  answer     Generics offer reusability  My answer will approach the problem differently  I ll start with a generic arrayCompare procedure that is only concerned with stepping through the arrays  From there  we ll build our other basic comparison functions like arrayEqual and arrayDeepEqual  etc     arrayCompare     a - gt  a - gt  Bool  - gt   a  - gt   a  - gt  Bool const arrayCompare   f   gt    x    xs     gt    y    ys     gt    x     undefined  amp  amp  y     undefined       true       Boolean  f  x   y    amp  amp  arrayCompare  f   xs   ys    In my opinion  the best kind of code doesn t even need comments  and this is no exception  There s so little happening here that you can understand the behaviour of this procedure with almost no effort at all  Sure  some of the ES6 syntax might seem foreign to you now  but that s only because ES6 is relatively new    As the type suggests  arrayCompare takes comparison function  f  and two input arrays  xs and ys  For the most part  all we do is call f  x   y  for each element in the input arrays  We return an early false if the user-defined f returns false     thanks to  amp  amp  s short-circuit evaluation  So yes  this means the comparator can stop iteration early and prevent looping through the rest of the input array when unnecessary     Strict comparison  Next  using our arrayCompare function  we can easily create other functions we might need  We ll start with the elementary arrayEqual  hellip      equal    a - gt  a - gt  Bool const equal   x   gt  y   gt    x     y    notice  triple equal     arrayEqual     a  - gt   a  - gt  Bool const arrayEqual     arrayCompare  equal   const xs    1 2 3  const ys    1 2 3  console log  arrayEqual  xs   ys            gt  true     1     1   amp  amp   2     2   amp  amp   3     3       gt  true  const zs     1   2   3   console log  arrayEqual  xs   zs            gt  false     1      1                                gt  false   Simple as that  arrayEqual can be defined with arrayCompare and a comparator function that compares a to b using      for strict equality    Notice that we also define equal as it s own function  This highlights the role of arrayCompare as a higher-order function to utilize our first order comparator in the context of another data type  Array      Loose comparison  We could just as easily defined arrayLooseEqual using a    instead  Now when comparing 1  Number  to  1   String   the result will be true  hellip      looseEqual    a - gt  a - gt  Bool const looseEqual   x   gt  y   gt    x    y    notice  double equal     arrayLooseEqual     a  - gt   a  - gt  Bool const arrayLooseEqual     arrayCompare  looseEqual   const xs    1 2 3  const ys     1   2   3   console log  arrayLooseEqual  xs   ys          gt  true     1     1    amp  amp   2     2    amp  amp   3     3        gt  true     Deep comparison  recursive   You ve probably noticed that this is only shallow comparison tho  Surely Tom     s solution is  The Right Way     because it does implicit deep comparison  right    Well our arrayCompare procedure is versatile enough to use in a way that makes a deep equality test a breeze  hellip      isArray    a - gt  Bool const isArray     Array isArray     arrayDeepCompare     a - gt  a - gt  Bool  - gt   a  - gt   a  - gt  Bool const arrayDeepCompare   f   gt    arrayCompare  a   gt  b   gt      isArray  a   amp  amp  isArray  b          arrayDeepCompare  f   a   b          f  a   b    const xs    1  2  3    const ys    1  2   3     console log  arrayDeepCompare  equal   xs   ys       gt  false     1     1   amp  amp   2     2   amp  amp   3      3               gt  false  console log  arrayDeepCompare  looseEqual   xs   ys       gt  true     1    1   amp  amp   2    2   amp  amp   3     3                       gt  true   Simple as that  We build a deep comparator using another higher-order function  This time we re wrapping arrayCompare using a custom comparator that will check if a and b are arrays  If so  reapply arrayDeepCompare otherwise compare a and b to the user-specified comparator  f   This allows us to keep the deep comparison behavior separate from how we actually compare the individual elements  Ie  like the example above shows  we can deep compare using equal  looseEqual  or any other comparator we make   Because arrayDeepCompare is curried  we can partially apply it like we did in the previous examples too     arrayDeepEqual     a  - gt   a  - gt  Bool const arrayDeepEqual     arrayDeepCompare  equal      arrayDeepLooseEqual     a  - gt   a  - gt  Bool const arrayDeepLooseEqual     arrayDeepCompare  looseEqual    To me  this already a clear improvement over Tom     s solution because I can explicitly choose a shallow or deep comparison for my arrays  as needed     Object comparison  example   Now what if you have an array of objects or something   Maybe you want to consider those arrays as  equal  if each object has the same id value  hellip      idEqual     id  Number  - gt   id  Number  - gt  Bool const idEqual   x   gt  y   gt    x id     undefined  amp  amp  x id     y id     arrayIdEqual     a  - gt   a  - gt  Bool const arrayIdEqual     arrayCompare  idEqual   const xs     id 1    id 2   const ys     id 1    id 2   console log  arrayIdEqual  xs   ys       gt  true     1     1   amp  amp   2     2                 gt  true  const zs     id 1    id 6   console log  arrayIdEqual  xs   zs       gt  false     1     1   amp  amp   2     6                 gt  false   Simple as that  Here I ve used vanilla JS objects  but this type of comparator could work for any object type  even your custom objects  Tom     s solution would need to be completely reworked to support this kind of equality test  Deep array with objects  Not a problem  We built highly versatile  generic functions  so they ll work in a wide variety of use cases   const xs     id 1     id 2    const ys     id 1     id 2    console log  arrayCompare  idEqual   xs   ys           gt  false console log  arrayDeepCompare  idEqual   xs   ys       gt  true     Arbitrary comparison  example   Or what if you wanted to do some other kind of kind of completely arbitrary comparison   Maybe I want to know if each x is greater than each y  hellip      gt    Number - gt  Number - gt  Bool const gt   x   gt  y   gt    x  gt  y     arrayGt     a  - gt   a  - gt  Bool const arrayGt   arrayCompare  gt   const xs    5 10 20  const ys    2 4 8  console log  arrayGt  xs   ys           gt  true     5  gt  2   amp  amp   10  gt  4   amp  amp   20  gt  8       gt  true  const zs    6 12 24  console log  arrayGt  xs   zs           gt  false     5  gt  6                               gt  false     Less is More  You can see we re actually doing more with less code  There s nothing complicated about arrayCompare itself and each of the custom comparators we ve made have a very simple implementation   With ease  we can define exactly how we wish for two arrays to be compared  mdash  shallow  deep  strict  loose  some object property  or some arbitrary computation  or any combination of these  mdash  all using one procedure  arrayCompare  Maybe even dream up a RegExp comparator   I know how kids love those regexps  hellip   Is it the fastest  Nope  But it probably doesn t need to be either  If speed is the only metric used to measure the quality of our code  a lot of really great code would get thrown away  mdash  That s why I m calling this approach The Practical Way  Or maybe to be more fair  A Practical Way  This description is suitable for this answer because I m not saying this answer is only practical in comparison to some other answer  it is objectively true  We ve attained a high degree of practicality with very little code that s very easy to reason about  No other code can say we haven t earned this description   Does that make it the  right  solution for you   That s up for you to decide  And no one else can do that for you  only you know what your needs are  In almost all cases  I value straightforward  practical  and versatile code over clever and fast kind  What you value might differ  so pick what works for you     Edit  My old answer was more focused on decomposing arrayEqual into tiny procedures  It s an interesting exercise  but not really the best  most practical  way to approach this problem  If you re interested  you can see this revision history

User · Answer

This simple solution works for me  function areEqual a  b       let x   0      for  n in a           if  a n     b n   x   1           else  x   0             return x     a    1 2 3   b    1 2 3       console log areEqual a b       true   I used it in this simple real code application   x000D   x000D   lt script gt  x000D  let corrette    1   x000D  let risposte       x000D   x000D  function areEqual a  b   x000D   let x   0  x000D   for  n in a   x000D    if  a n     b n   x   1   x000D    else  x   0   x000D     x000D   if  x  console log  The 2 arrays are equal    x000D   return x  x000D    x000D   x000D   lt  script gt  x000D   x000D  Apporto di attrezzatura per cucina da parte del proprietario x000D   lt button onclick  risposte 0  1  gt Capitale proprio lt  button gt  x000D   lt button onclick  risposte 0  0  gt Capitale di debito lt  button gt  x000D   lt button onclick  risposte 0  0  gt Debito commerciale lt  button gt  x000D   x000D   lt br gt  lt hr gt  x000D   lt button onclick  if areEqual corrette risposte   controlla innerHTML  Esatto  else controlla innerHTML  No    gt Controlla le risposte lt  button gt  x000D   lt div id  controlla  gt  lt  div gt  x000D   x000D   x000D

User · Answer

Only works for one level Arrays  String or Numbers type   function isArrayEqual ar1  ar2         return  ar1 some item   gt  ar2 indexOf item      -1   amp  amp  ar1 length     ar2 length

User · Answer

I like to use the Underscore library for array object heavy coding projects     in Underscore and Lodash whether you re comparing arrays or objects it just looks like this     isEqual array1  array2       returns a boolean   isEqual object1  object2     returns a boolean    Underscore isEqual docs Lodash isEqual docs

User · Answer

If the array is plain and the order is matter so this two lines may help    Assume var a     a   b    c    var b     a   e    c       if a length     b length  return false  return  a reduce    function prev next idx  arr   return prev    next    b idx    false       Reduce walks through one of array and returns  false  if at least one element of  a  is nor equial to element of  b  Just wrap this into function

User · Answer

Here is a Typescript version     https   stackoverflow com a 16436975 2589276 export function arraysEqual lt T gt  a  Array lt T gt   b  Array lt T gt    boolean       if  a     b  return true     if  a    null    b    null  return false     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      https   stackoverflow com a 16436975 2589276 export function arraysDeepEqual lt T gt  a  Array lt T gt   b  Array lt T gt    boolean       return JSON stringify a      JSON stringify b      Some test cases for mocha   it  arraysEqual   function          let a    1 2      let b    1 2      let c    2 3      let d    2  3      let e     car   apple   banana       let f     car   apple   banana       let g     car   apple   banan8        expect arraysEqual a  b   to equal true      expect arraysEqual c  d   to equal true      expect arraysEqual a  d   to equal false      expect arraysEqual e  f   to equal true      expect arraysEqual f  g   to equal false      it  arraysDeepEqual   function          let a    1 2      let b    1 2      let c    2 3      let d    2  3      let e     car   apple   banana       let f     car   apple   banana       let g     car   apple   banan8       let h     1 2   apple   banan8       let i     1 2   apple   banan8       let j     1 3   apple   banan8        expect arraysDeepEqual a  b   to equal true      expect arraysDeepEqual c  d   to equal true      expect arraysDeepEqual a  d   to equal false      expect arraysDeepEqual e  f   to equal true      expect arraysDeepEqual f  g   to equal false      expect arraysDeepEqual h  i   to equal true      expect arraysDeepEqual h  j   to equal false

User · Answer

In a simple way uning stringify but at same time thinking in complex arrays     Simple arrays      var a    1 2 3 4     var b    4 2 1 4     JSON stringify a sort        JSON stringify b sort       true      Complex arrays      var a     id 5 name  as    id 2 name  bes       var b     id 2 name  bes    id 5 name  as       JSON stringify a sort function a b   return a id - b id        JSON stringify b sort function a b   return a id - b id       true      Or we can create a sort function      function sortX a b      return a id -b id    change for the necessary rules       JSON stringify a sort sortX       JSON stringify b sort sortX      true

User · Answer

This I think is the simplest way to do it using JSON stringify  and it may be the best solution in some situations   JSON stringify a1      JSON stringify a2     This converts the objects a1 and a2 into strings so they can be compared  The order is important in most cases  for that can sort the object using a sort algorithm shown in one of the above answers   Please do note that you are no longer comparing the object but the string representation of the object  It may not be exactly what you want

User · Answer

This function compares two arrays of arbitrary shape and dimesionality   function equals a1  a2         if   Array isArray a1      Array isArray a2             throw new Error  Arguments to function equals a1  a2  must be arrays                if  a1 length     a2 length            return false             for  var i 0  i lt a1 length  i              if  Array isArray a1 i    amp  amp  Array isArray a2 i                  if  equals a1 i   a2 i                      continue                else                   return false                          else               if  a1 i      a2 i                     return false                                     return true

User · Answer

With an option to compare the order or not   function arraysEqual a1  a2  compareOrder        if  a1 length     a2 length            return false             return a1 every function value  index            if  compareOrder                return value     a2 index             else               return a2 indexOf value   gt  -1

User · Answer

This method is one that only works on scalar arrays  like the  second voted answer on this question   x000D   x000D  var arrs         1  2  3    1  2  3       true     1  2  3  4    1  2  3       false     1  2  3    1  2  3  4       false    const arraysEqual    one  two    gt   one filter  i  n    gt  two n      i  length     one length   amp  amp   two filter  i  n    gt  one n      i  length     two length   arrs forEach arr   gt      console log arraysEqual arr 0   arr 1       x000D   x000D   x000D   Without ES6 syntax   x000D   x000D  var arrs         1  2  3    1  2  3       true     1  2  3  4    1  2  3       false     1  2  3    1  2  3  4       false    function arraysEqual one  two      return  one filter  i  n    gt  two n      i  length     one length   amp  amp   two filter  i  n    gt  one n      i  length     two length     arrs forEach arr   gt      console log arraysEqual arr 0   arr 1       x000D   x000D   x000D

User · Answer

var a1    1 2 3 6   var a2    1 2 3 5    function check a  b      return  a length    b length    false      a every function row  index        return a index     b index              check a1  a2            OR           var a1    1 2 3 6   var a2    1 2 3 6    function check a  b      return  a length    b length    false        a some function row  index        return a index     b index               check a1  a2

User · Answer

I use this code with no issues so far   if a join      b join              It works even if there are commas in an item

User · Answer

var er     id  23  name  23222     id  222  name  23222222     var er2     id  23  name  23222     id  222  name  23222222      var result    JSON stringify er     JSON stringify er2       true   It works json objects well if the order of the property of each entry is not changed   var er     name  23222  id  23     id  222  name  23222222     var er2     id  23  name  23222     id  222  name  23222222      var result    JSON stringify er     JSON stringify er2       false     But there is only one property or value in each entry of the array  this will work fine

User · Answer

this script compares Object  Arrays and multidimensional array  function compare a b        var primitive   string   number   boolean         if primitive indexOf typeof a    -1  amp  amp  primitive indexOf typeof a    primitive indexOf typeof b  return a   b       if typeof a   typeof b    a length   b length return false       for i in a             if  compare a i  b i   return false              return true      first line checks whether it s a primitive type  if so it compares the two parameters   if they are Objects  it iterates over the Object and check every element recursivly    Usage   var a  1 2  1 2    var b  1 2  1 2    var isEqual compare a b      true

User · Answer

You can disqualify  sameness  if the number of elements do not match or if one of the elements is not in the other s array  Here is simple function that worked for me       function isSame arr1 arr2            var same true          for var i 0 i  lt  arr1 length i                  if   jQuery inArray arr1 i  arr2     arr1 length  arr2 length                   same false                                          return same

User · Answer

Actually  in the Lodash documentation  they give two pretty good examples for comparing and return fresh arrays for both differences and similarities  respectively in the examples below    import   differenceWith  intersectionWith  isEqual   from  lodash   differenceWith       a  1      b  1          a  1      b  1      c  1       isEqual            the bigger array needs to go first   differenceWith       a  1      b  1      c  1          a  1      b  1       isEqual          c  1      intersectionWith       a  1      b  1          a  1      b  1      c  1       isEqual          a  1      b  1    this one doesn t care about which is bigger   If you won t always know which array will be bigger  you can write a helper function for it like so   const biggerFirst    arr1  arr2    gt      return arr1 length  gt  arr2 length    arr1  arr2     arr2  arr1     const  big  small    biggerFirst       a  1      b  1          a  1      b  1      c  1        differenceWith big  small  isEqual     even though we have no idea which is bigger when they are fed to biggerFirst     From what I can tell  these match deeply as well so that s pretty nice   I know relying on libraries for everything shouldn t be applauded  but this is the most concise clean solution I ve found to a really common problem  Hope it helps someone

User · Answer

If they are two arrays of numbers or strings only  this is a quick one-line one  const array1    1  2  3   const array2    1  3  4   console log array1 join          array2 join         false  const array3    1  2  3   const array4    1  2  3   console log array3 join          array4 join         true

User · Answer

Another approach with very few code  using Array reduce and Array includes    arr1 length    arr2 length  amp  amp  arr1 reduce  a  b    gt  a  amp  amp  arr2 includes b   true    If you want to compare also the equality of order   arr1 length    arr2 length  amp  amp  arr1 reduce  a  b  i    gt  a  amp  amp  arr2 i   true     The length check ensures that the set of elements in one array isn t just a subset of the other one  The reducer is used to walk through one array and search for each item in other array  If one item isn t found the reduce function returns false     In the first example it s being tested that an element is included The second example check for the order too

User · Answer

Already some great answers But i would like to share anther idea which has proven to be reliable in comparing arrays  We can compare two array using JSON stringify       It will create a string out the the array and thus compare two obtained strings from two array for equality  JSON stringify  1  a 1  2      JSON stringify  1  a 1  2     true  JSON stringify  1  a 1  2      JSON stringify  1  a 2  2     false  JSON stringify  1  a 1  2      JSON stringify  1  a 2   3 4  2     false  JSON stringify  1  a 1   3 4  2      JSON stringify  1  a 2   3 4  2     false  JSON stringify  1  a 2   3 4  2      JSON stringify  1  a 2   3 4  2     true  JSON stringify  1  a 2   3 4  2      JSON stringify  1  a 2   3 4  5   2     false  JSON stringify  1  a 2   3 4  4   2      JSON stringify  1  a 2   3 4  5   2     false  JSON stringify  1  a 2   3 4  5   2      JSON stringify  1  a 2   3 4  5   2     true

User · Answer

I came up with another way to do it  Use join     to change them to string  and then compare 2 strings   var a1 str   a1 join          a2 str   a2 join       if  a2 str     a1 str

User · Answer

Here s a CoffeeScript version  for those who prefer that   Array prototype equals    array  - gt    return false if not array   if the other array is a falsy value  return   return false if  length isnt array length   compare lengths - can save a lot of time    for item  index in       if item instanceof Array and array index  instanceof Array   Check if we have nested arrays       if not item equals array index     recurse into the nested arrays         return false     else if this index     array index        return false   Warning - two different object instances will never be equal   x 20      x 20    true   All credits goes to  tomas-zato

User · Answer

This compares 2 unsorted arrays   function areEqual a  b      if   a length    b length        return false        return a filter function i        return  b includes i        length     0

User · Answer

In my case compared arrays contain only numbers and strings  This function will show you if arrays contain same elements   function are arrs match arr1  arr2       return arr1 sort   toString       arr2 sort   toString       Let s test it   arr1    1  2  3   nik   arr2     nik   3  1  2  arr3    1  2  5   console log  are arrs match arr1  arr2     true console log  are arrs match arr1  arr3     false

User · Answer

I have used   to join array and create a string to compare  for scenarios complex than this example you can use some other separator   var a1    1 2 3   var a2    1 2 3   if  a1 length     a2 length       console log  a1 and a2 are not equal    else if a1 join          a2 join           console log  a1 and a2 are equal    else     console log  a1 and a2 are not equal

User · Answer

A simple approach   function equals a  b        if   a  amp  amp   b       a  amp  amp  b       a  amp  amp   b      a length     b length             return false             var isDifferent   a some function  element  index             return element     b index                return  isDifferent

User · Answer

We can use every   and includes   method to compare two arrays   function check a1 a2      let result   a1 every  x   gt     return a2 includes x         return result

User · Answer

My solution compares Objects  not Arrays  This would work in the same way as Tom     s as Arrays are Objects  but without the Warning   Object prototype compare to   function comparable           Is the value being compared an object     if comparable instanceof Object               Count the amount of properties in  comparable         var count of comparable   0          for p in comparable  count of comparable                Loop through all the properties in  this         for property in this                   Decrements once for every property in  this             count of comparable--                  Prevents an infinite loop             if property     compare to                        Is the property in  comparable                 if property in comparable                           Is the property also an Object                     if this property  instanceof Object                               Compare the properties if yes                         if   this property  compare to comparable property                                      Return false if the Object properties don t match                             return false                                                   Are the values unequal                       else if this property      comparable property                                Return false if they are unequal                         return false                                          else                           Return false if the property is not in the object being compared                     return false                                                  else               Return false if the value is anything other than an object         return false                Return true if their are as many properties in the comparable object as  this     return count of comparable    0      Hope this helps you or anyone else searching for an answer

User · Answer

tried deep-equal and it worked  var eq   require  deep-equal    eq  a  1  b  2  c   3  4     c   3  4   a  1  b  2

User · Answer

I would do like this    2 3 4 5      2 3 4 5  toString     When you use the      operator  javascript check if the values left and right  is the same type  if it s different javascript try to convert both side in the same type   Array    String   Array has toString method so javascript use it to convert them to the same type  work the same way writing like this    2 3 4 5  toString       2 3 4 5  toString

User · Answer

I believe in plain JS and with ECMAScript 2015  which is sweet and simple to understand   var is arrays compare similar   function  array1  array2         let flag   true       if  array1 length    array2 length                check first array1 object is available in array2 index         array1 every  array obj   gt                if  flag                    if   array2 includes array obj                         flag   false                                                          then vice versa check array2 object is available in array1 index         array2 every  array obj   gt                if  flag                    if   array1 includes array obj                         flag   false                                                       return flag        else           return false             hope it will help someone

User · Answer

We could do this the functional way  using every  https   developer mozilla org en docs Web JavaScript Reference Global Objects Array every   function compareArrays array1  array2        if  array1 length     array2 length          return array1 every  a  index    gt  a     array2 index       else         return false       test var a1    1 2 3   var a2    1 2 3    var a3     a    r    r    a    y    1   var a4     a    r    r    a    y    2    console log compareArrays a1 a2      true console log compareArrays a1 a3      false console log compareArrays a3 a4      false

User · Answer

If you are writing a test code  then import chai from  chai   const arr1    2  1   const arr2    2  1   chai expect arr1  to eql arr2      Will pass   eql  is data compare instead of object compare

User · Answer

You can simply use isEqual from lodash library  It is very efficient and clean  import  isEqual  from  quot lodash quot    const isTwoArraysEqual   isEqual array1  array2

[javascript] How to compare arrays in JavaScript?

Examples related to javascript

Examples related to arrays

Examples related to json