I have these two arrays: one is filled with information from an ajax request and another stores the buttons the user clicks on. I use this code (I filled with sample numbers):

```
var array1 = [2, 4];
var array2 = [4, 2]; //It cames from the user button clicks, so it might be disordered.
array1.sort(); //Sorts both Ajax and user info.
array2.sort();
if (array1==array2) {
doSomething();
}else{
doAnotherThing();
}
```

But it always gives `false`

, even if the two arrays are the same, but with different name. (I checked this in Chrome's JS Console). So, is there any way I could know if these two arrays contain the same? Why is it giving `false`

? How can I know which values in the first array are not in the second?

If your array items are not objects- if they are numbers or strings, for example, you can compare their joined strings to see if they have the same members in any order-

```
var array1= [10, 6, 19, 16, 14, 15, 2, 9, 5, 3, 4, 13, 8, 7, 1, 12, 18, 11, 20, 17];
var array2= [12, 18, 20, 11, 19, 14, 6, 7, 8, 16, 9, 3, 1, 13, 5, 4, 15, 10, 2, 17];
if(array1.sort().join(',')=== array2.sort().join(',')){
alert('same members');
}
else alert('not a match');
```

JavaScript has primitive data types and non-primitive data types.

For primitive data types, `==`

and `===`

check whether the things on either side of the bars have the same value. That's why `1 === 1`

is true.

For non-primitive data types like arrays, `==`

and `===`

check for reference equality. That is, they check whether `arr1`

and `arr2`

are the same object. In your example, the two arrays have the same objects in the same order, but are not equivalent.

Two arrays, `arr1`

and `arr2`

, have the same members if and only if:

- Everything in
`arr2`

is in`arr1`

AND

- Everything in
`arr1`

is in`arr2`

So this will do the trick (ES2016):

```
const containsAll = (arr1, arr2) =>
arr2.every(arr2Item => arr1.includes(arr2Item))
const sameMembers = (arr1, arr2) =>
containsAll(arr1, arr2) && containsAll(arr2, arr1);
sameMembers(arr1, arr2); // `true`
```

This second solution using Underscore is closer to what you were trying to do:

```
arr1.sort();
arr2.sort();
_.isEqual(arr1, arr2); // `true`
```

It works because `isEqual`

checks for "deep equality," meaning it looks at more than just reference equality and compares values.

You also asked how to find out which things in `arr1`

are not contained in `arr2`

.

This will do it (ES2015):

```
const arr1 = [1, 2, 3, 4];
const arr2 = [3, 2, 1];
arr1.filter(arr1Item => !arr2.includes(arr1Item)); // `[4]`
```

You could also use Underscore's `difference`

: method:

```
_.difference(arr1, arr2); // `[4]`
```

See @Redu's comment—my solution is for `sameMembers`

, but what you may have in mind is `sameMembersInOrder`

also-known-as `deepEquals`

.

If you don't care about the order of the members of the arrays, ES2015+'s `Set`

may be a better data structure than `Array`

. See the MDN notes on how to implement `isSuperset`

and `difference`

using dangerous monkey-patching.

Object equality check:`JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())`

The above test also works with arrays of objects in which case use a sort function as documented in http://www.w3schools.com/jsref/jsref_sort.asp

Might suffice for small arrays with flat JSON schemas.

Our aim is basically to check whether 2 arrays are equal sets. set is the mathematically defined ** set**. Fastest sorting asymptotically takes

```
// assumes array elements are primitive types
function areArraysEqualSets(a1, a2) {
let superSet = {};
for (let i = 0; i < a1.length; i++) {
const e = a1[i] + typeof a1[i];
superSet[e] = 1;
}
for (let i = 0; i < a2.length; i++) {
const e = a2[i] + typeof a2[i];
if (!superSet[e]) {
return false;
}
superSet[e] = 2;
}
for (let e in superSet) {
if (superSet[e] === 1) {
return false;
}
}
return true;
}
```

Note that this function works with arrays of primitive types and assumes a1 and a2 are arrays

When you compare those two arrays, you're comparing the objects that represent the arrays, not the contents.

You'll have to use a function to compare the two. You could write your own that simply loops though one and compares it to the other after you check that the lengths are the same.

I had simple integer values in a Game project

Had less number of values in each array, also, needed that original array untouched

So, I did the below, it worked fine. (Code edited to paste here)

```
var sourceArray = [1, 2, 3];
var targetArray = [3, 2, 1];
if (sourceArray.length !== targetArray.length) {
// not equal
// did something
return false;
}
var newSortedSourceArray = sourceArray.slice().sort();
var newSortedTargetArray = targetArray.slice().sort();
if (newSortedSourceArray.toString() !== newSortedTargetArray.toString()) { // MAIN CHECK
// not equal
// did something
return false;
}
else {
// equal
// did something
// continued further below
}
// did some more work
return true;
```

Hope that helps.

We'll use Ramda's `equals`

function, but instead we can use Lodash's or Underscore's `isEqual`

:

```
const R = require('ramda');
const arraysHaveSameValues = (arr1, arr2) => R.equals( [...arr1].sort(), [...arr2].sort() )
```

Using the spread opporator, we avoid mutating the original arrays, and we keep our function pure.

What about this? ES 2017 i suppose:

```
const array1 = [1, 3, 5];
const array2 = [1, 5, 3];
const isEqual = (array1.length === array2.length) && (array1.every(val => array2.includes(val)));
console.log(isEqual);
```

1st condition checks if both arrays have same length and 2nd condition checks if 1st array is a subset of the 2nd array. Combining these 2 conditions should then result in comparison of all items of the 2 arrays irrespective of the ordering of elements.

The above code will only work if both arrays have non-duplicate items.

kindly check this answer

```
var arr1= [12,18];
var arr2= [12, 18, 20, 11, 19, 14, 6, 7, 8, 16, 9, 3, 1, 13, 5, 4, 15, 10, 2, 17];
for(i=0;i<arr1.length;i++)
{
var array1=arr1[i];
for(j=0;j<arr2.length;j++)
{
var array2=arr2[j];
if(array1==array2)
{
return true;
}
}
}
```

If the items in the array are primitives (numbers or single characters), you can use a combination of comparing lengths, and using sets.

```
function equalArrayItems(arr1, arr2) {
if (arr1.length !== arr2.length) return false
const set1 = new Set(arr1)
const set2 = new Set(arr2)
const set3 = new Set(arr1, arr2)
return set1.size === set3.size && set2.size === set3.size
}
```

Answering after long time but hope this will help somebody who looking for a simple solution and modern newbies.

Now we can achieve this using multiple libraries like `lodash`

, `underscore`

, etc. (These becomes part of the project nowadays due to simplicity, multiple features and high usage)

You can use intersection from lodash library.

```
_.intersection(['2-1', '1'], ['2-2', '3-1', '2-1']);
// => ['2-1']
```

This will work for any data type..

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 < array1.length; i++) {
for (let j = 0; j < array2.length; j++) {
if (array1[i] === array2[j]) {
return true;
}
}
}
// Return if no common element exist
return false;
}
```

```
function arraysEqual(_arr1, _arr2) {
if (!Array.isArray(_arr1) || ! Array.isArray(_arr2) || _arr1.length !== _arr2.length)
return false;
var arr1 = _arr1.concat().sort();
var arr2 = _arr2.concat().sort();
for (var i = 0; i < arr1.length; i++) {
if (arr1[i] !== arr2[i])
return false;
}
return true;
}
```

Note that this doesn't modify original arrays unlike a previous answer.

If you want to check only if two arrays have same values (regardless the number of occurrences and order of each value) you could do this by using lodash:

```
_.isEmpty(_.xor(array1, array2))
```

Short, simple and pretty!

```
Array.prototype.compare = function(testArr) {
if (this.length != testArr.length) return false;
for (var i = 0; i < testArr.length; i++) {
if (this[i].compare) { //To test values in nested arrays
if (!this[i].compare(testArr[i])) return false;
}
else if (this[i] !== testArr[i]) return false;
}
return true;
}
var array1 = [2, 4];
var array2 = [4, 2];
if(array1.sort().compare(array2.sort())) {
doSomething();
} else {
doAnotherThing();
}
```

Maybe?

If you are using the Prototype Framework, you can use the intersect method of an array to find out of they are the same (regardless of the order):

```
var array1 = [1,2];
var array2 = [2,1];
if(array1.intersect(array2).length === array1.length) {
alert("arrays are the same!");
}
```

You can use `reduce`

instead of loops to appear clever, but at the risk of having your fellow developers think of you as a smart-ass.

```
function isArrayContentSame(a, b) {
if (Array.isArray(a) && Array.isArray(b) && a.length == b.length) {
a = a.concat().sort()
b = b.concat().sort()
return a.reduce((acc,e,i) => acc && e === b[i], true)
} else {
return false;
}
}
```

Simple solution for shallow equality using ES6:

```
const arr1test = arr1.slice().sort()
const arr2test = arr2.slice().sort()
const equal = !arr1test.some((val, idx) => val !== arr2test[idx])
```

Creates shallow copies of each array and sorts them. Then uses `some()`

to loop through `arr1test`

values, checking each value against the value in `arr2test`

with the same index. If all values are equal, `some()`

returns `false`

, and in turn `equal`

evaluates to `true`

.

Could also use `every()`

, but it would have to cycle through every element in the array to satisfy a `true`

result, whereas `some()`

will bail as soon as it finds a value that is not equal:

```
const equal = arr1test.every((val, idx) => val === arr2test[idx])
```

It's 2020 already but I noticed that most of the other solutions use sort, O(n*log n), use libraries or have O(n^2) complexity.

Here is a pure Javascript solution with linear complexity, O(n):

```
/**
* Check if two arrays of strings or numbers have the same values regardless of the order
* @param {string[]|number[]} arr1
* @param {string[]|number[]} arr2
* @return {boolean}
*/
compareArrays = (arr1, arr2) => {
if (arr1.length !== arr2.length) return false;
const lk1 = {};
const lk2 = {};
let i = arr1.length;
while (--i >= 0) {
lk1[arr1[i]] = true;
lk2[arr2[i]] = true
}
i = arr1.length;
while (--i >= 0) {
const v = arr1[i];
if (lk1[v] !== lk2[v]) return false;
}
return true
}
```

Tests:

```
compareArrays([2, 4], [4, 2]) => true
compareArrays([2, 4], [4, 2, 7]) => false
compareArrays([], []) => true
```

Try this

```
function arraysEqual(arr1, arr2){
if (!Array.isArray(arr1) || !Array.isArray(arr2) || arr1.length!=arr2.length)
return false;
return arr1.length==arr1.filter(word => arr2.includes(word)).length;
}
```

I have another way based on the accepted answer.

```
function compareArrays(array1, array2) {
if (
!Array.isArray(array1)
|| !Array.isArray(array2)
|| array1.length !== array2.length
) return false;
var first = array1.sort().map(value => (String(value))).join();
var second = array2.sort().map(value => (String(value))).join();
return first == second ? true : false;
}
```

A function to Compare two Arrays, to check if both has same elements. Even if they are out of order...

It's good for simple arrays. [String,Number,Boolean,null,NaN].

I don't use .sort(), it modifies the original array. Some say's its bad...

Caution. This function is limited it can't compare Objects"[],{}" or functions within these Arrays, arrays it's self are Objects.

```
let arraysHasSameElements = (arr1, arr2) => {
let count =
// returns counting of occurrences.
(arr, val) => arr.reduce((count, curr) => (curr === val ? 1 : 0) + count, 0);
/* this will return true if lengths of the arrays is equal.
then compare them.*/
return arr1.length === arr2.length
// compare arr1 against arr2.
&& arr1.reduce((checks, val) =>
/* creating array of checking if a value has equal amount of occurrences
in both arrays, then adds true 'check'. */
checks.concat(count(arr1, val) === count(arr2, val)), [])
// checking if each check is equal to true, then .every() returns true.
.every(check => check);
}
let arr1 = ['',-99,true,NaN,21,null,false,'help',-99,'help',NaN],
arr2 = [null,-99,'',NaN,NaN,false,true,-99,'help',21,'help'];
arraysHasSameElements(arr1, arr2); //true
let arr3 = [false,false,false,false,false,false],
arr4 = [false,false,false,false,false,false]
arraysHasSameElements(arr3, arr4); //true
// here we have uncommented version.
let arraysHasSameElements = (arr1, arr2) => {
let count = (arr, val) => arr.reduce((count, curr) => (curr === val ? 1:0) + count, 0);
return arr1.length === arr2.length && arr1.reduce((checks, val) =>
checks.concat(count(arr1, val) === count(arr2, val)), []).every(check => check);
}
```

Simple Solution to compare the two arrays:

```
var array1 = [2, 4];
var array2 = [4, 2];
array1.sort();
array2.sort();
if (array1[0] == array2[0]) {
console.log("Success");
}else{
console.log("Wrong");
}
```

©2020 All rights reserved.