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');

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 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!

Why your code didn't work

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.

Solutions

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.

A solution to your third question

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]`

UPDATE

See @Redu's comment—my solution is for sameMembers, but what you may have in mind is sameMembersInOrder also-known-as deepEquals.

UPDATE 2

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.

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.

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!");

}

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.

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;

    }

}

}

Using ES6

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.