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?
To compare arrays, loop through them and compare every value:
// Warn if overriding existing method
if(Array.prototype.equals)
console.warn("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.");
// 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;
// if the argument is the same array, we can be sure the contents are same as well
if(array === this)
return true;
// compare lengths - can save a lot of time
if (this.length != array.length)
return false;
for (var i = 0, l=this.length; i < l; i++) {
// Check if we have nested arrays
if (this[i] instanceof Array && 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, "equals", {enumerable: false});
[1, 2, [3, 4]].equals([1, 2, [3, 2]]) === false;
[1, "2,3"].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 "But it is much faster to compare strings - no loops..." 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:
I've stated above, that two object instances will never be equal, even if they contain same data at the moment:
({a:1, foo:"bar", numberOfTheBeast: 666}) == ({a:1, foo:"bar", 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 => 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 && object2[propName] instanceof Array) {
// recurse into the nested arrays
if (!this[propName].equals(object2[propName]))
return false;
}
else if (this[propName] instanceof Object && object2[propName] instanceof Object) {
// recurse into another objects
//console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
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 more complicated objects, look at this answer and it's super long 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 && 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 && array[i] instanceof Object) {
// recurse into another objects
//console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
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.
indexOf and containsSamy 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/
this[i] !== array[i] instead of !=. –
Fright equals instead of compare. At least in .NET, compare usually returns a signed int indicating which object is greater than the other. See: Comparer.Compare. –
Faludi for (var i = 0, len = this.length; i < len; i++) –
Acerose JSON.stringify(Object) for the comparison. gist.github.com/harmstyler/7896595 –
Mccurdy for(var i in object). For {a:1, b:2, c:666} i will become ("a", "b", "c") in that order. –
Nazarene if (!this || !array). It would be a rare but possible case where you'd get a TypeError on this.length because the this value was set to null or undefined. –
Vanitavanity .compare? –
Nazarene for (var i in myArray) { } because equals() is now a property and the loop will now loop once on this property. –
Winchester i would also contain "length" and other default properties. (in ancient IE) –
Nazarene Array.equals is not a built-in prototype according to ECMAScript specs. Please check your sources again. –
Nazarene Array is. The point is, that since Array is a built-in, you shouldn't modify its prototype. –
Seidule equals() function on the Array prototype, and if it's different (e.g. deep vs shallow comparisons, or even just adding a parameter to allow selection of deep or shallow comparison) your code suddenly starts breaking other scripts that use this function... –
Seidule if(typeof Array.prototype.equals != 'function') { ... }... Not ideal, but certainly a workaround. –
Ostrogoth ===. Now, code using your function will work incorrectly (because Array.equals() does something other than expected) in browsers that implement this new function. In browsers that do not have the new function, code using the new standard function, will appear to work, but not do what is expected. –
Seidule new ImprovedArray() whereas my solution works on anything instantiated as [] no matter whether it comes from external source, parsed JSON or your program. My answer has been here for 2 years and is still valid and doesn't break anything (only irritates some people which I don't care about). Observational evidence is the only thing superior to logical arguments (and what you say is logical and true). Meanwhile anybody who cares about the code he writes will read your comments and make his decision with your advice on mind. –
Nazarene Array.ptototype.equals should use a strict comparaison. Else things like [[]].equals([false]); will return true. –
Finecut 1 vs "1"). Anyway I don't think [[]].equals([false]); would return true by just looking on the code. Have you tested that? –
Nazarene [] != false === false your code never return false. Would be the same with [""].equals([false]); and for me [1].equals(["1"]) should return false –
Finecut "1" and 1 to be equal. Those like you, who are aware of the typing in javascript, will be skilled enough to edit the code to their needs. My code is just a template for you. –
Nazarene contains and indexOf function, which much like Zato's equals function, properly handle nested arrays. All the functions are added to the Array prototype. The code is available here: jsfiddle.net/SamyBencherif/8352y6yw –
Pagination While this only works for scalar arrays (see note below), it is short code:
array1.length === array2.length && array1.every(function(value, index) { return value === array2[index]})
Same as above but in ECMAScript 6 / CoffeeScript / TypeScript with Arrow Functions:
array1.length === array2.length && array1.every((value, index) => 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 in the comments, sorting the array and comparing may give accurate result:
const array2Sorted = array2.slice().sort();
array1.length === array2.length && 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 return true
a1.length==a2.length && a1.every((v,i)=>a2.includes(v)): var a1 =[1,2,3], a2 = [3,2,1]; (var a1 =[1,3,3], a2 = [1,1,3]; will not work as expected) –
Guess scalar being used, something I assume most of don't hear often. Might do this question justice by touching up on that piece and further clarifying the example... –
Gujral sort() method will mutate the original array, which is almost never a good thing. You should clone it beforehand. –
Amoretto array1.length === array2.length && array1.every(value=> array2.includes(value)) –
Whereon array1.length === array2.length to avoid unneeded sorting of array2 –
Monteria var array1 = [...];, then var array2 = array1;, then try to make them unequal with array1.push('banana')? You just fell victim to aliasing; var array2 = array1; isn't copying array1 into a new Array, it's aliasing the same Array array1 points to (there's only one actual Array, which both names refer to). –
Kellam 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
_.isEqual([1,2,3], [2,1,3]) => false –
Fezzan isEqual functionality, you can always use the lodash.isequal module –
Stentorian _.isEqual([1,2,3].sort(), [2,1,3].sort()) => true –
Lodie 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.
JSON.stringify() and how it can be the best choice depending on what you are trying to do. I shared what I found and it looks like its helping others decide. –
Boothe JSON.stringify() - for simple use cases it feels the easiest one... –
Ripply [1,2,3] == [1,2,3] +"" also works. –
Cryptocrystalline 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)=> v === a2[i]);
reduce (74%) by DEIs
a1.reduce((a, b) => a && a2.includes(b), true);
join & toString (78%) by Gaizka Allende & 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.
.lengthcomparison has been removed for a common benchmark (adda1.length === a2.lengthto 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.
It seems to me that jsbench is now sorting from fast (100%) to slower (for example 11%). The code sample contains arrEvery() and a slowed down version.
function arrEvery(a1,a2)
{
// user2782196: https://mcmap.net/q/37262/-how-to-compare-arrays-in-javascript
return a1.every((v,i)=> v === a2[i]);
}
// slowed down
function arrEveryWithSlowDown(a1,a2)
{
setTimeout(() => {
console.log("Slow down pal!");
}, 1500);
return a1.every((v,i)=> v === a2[i]);
}
The slowed down version of arrEvery has less percentage. The number in brackets might be the number of cycels / operations run.
Array.from({length: 1000}).map((a,v)=> ${v}.padStart(10,2)); –
Irrefutable sort() before a1 & a2 join. e.g. a1.sort().join("")===a2.sort().join("") –
Circumstantiate join('') is dangerous as ['foo', 'bar'].join('') == ['foobar'].join(''). I prefer a1 ==''+ a2. –
Salim [1, 2] will equal [2, 1], which is wrong in most cases. If you specifically want a unordered comparison, fine, you can sort, but that is not the normal case and not the question. –
Lanyard while would take 67% of the time it takes using stringify. This is somewhat similar to baker's percentages… –
Adenoma arrEveryWithSlowDown (412,985) the result was 10,75% compared to 98.31% for arrEvery (4,001,413) –
Pants arrEvery does not work for different sized arrays. –
Dormer ["a,b"] == "" + ["a", "b"] is true. –
Stipendiary 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.
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 -> a -> Bool) -> [a] -> [a] -> Bool
const arrayCompare = f => ([x,...xs]) => ([y,...ys]) =>
x === undefined && y === undefined
? true
: Boolean (f (x) (y)) && 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 &&'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.
Next, using our arrayCompare function, we can easily create other functions we might need. We'll start with the elementary arrayEqual …
// equal :: a -> a -> Bool
const equal = x => y =>
x === y // notice: triple equal
// arrayEqual :: [a] -> [a] -> Bool
const arrayEqual =
arrayCompare (equal)
const xs = [1,2,3]
const ys = [1,2,3]
console.log (arrayEqual (xs) (ys)) //=> true
// (1 === 1) && (2 === 2) && (3 === 3) //=> true
const zs = ['1','2','3']
console.log (arrayEqual (xs) (zs)) //=> false
// (1 === '1') //=> 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).
We could just as easily defined arrayLooseEqual using a == instead. Now when comparing 1 (Number) to '1' (String), the result will be true …
// looseEqual :: a -> a -> Bool
const looseEqual = x => y =>
x == y // notice: double equal
// arrayLooseEqual :: [a] -> [a] -> Bool
const arrayLooseEqual =
arrayCompare (looseEqual)
const xs = [1,2,3]
const ys = ['1','2','3']
console.log (arrayLooseEqual (xs) (ys)) //=> true
// (1 == '1') && (2 == '2') && (3 == '3') //=> true
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 …
// isArray :: a -> Bool
const isArray =
Array.isArray
// arrayDeepCompare :: (a -> a -> Bool) -> [a] -> [a] -> Bool
const arrayDeepCompare = f =>
arrayCompare (a => b =>
isArray (a) && 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)) //=> false
// (1 === 1) && (2 === 2) && (3 === '3') //=> false
console.log (arrayDeepCompare (looseEqual) (xs) (ys)) //=> true
// (1 == 1) && (2 == 2) && (3 == '3') //=> 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] -> [a] -> Bool
const arrayDeepEqual =
arrayDeepCompare (equal)
// arrayDeepLooseEqual :: [a] -> [a] -> 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.
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 …
// idEqual :: {id: Number} -> {id: Number} -> Bool
const idEqual = x => y =>
x.id !== undefined && x.id === y.id
// arrayIdEqual :: [a] -> [a] -> Bool
const arrayIdEqual =
arrayCompare (idEqual)
const xs = [{id:1}, {id:2}]
const ys = [{id:1}, {id:2}]
console.log (arrayIdEqual (xs) (ys)) //=> true
// (1 === 1) && (2 === 2) //=> true
const zs = [{id:1}, {id:6}]
console.log (arrayIdEqual (xs) (zs)) //=> false
// (1 === 1) && (2 === 6) //=> 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)) //=> false
console.log (arrayDeepCompare (idEqual) (xs) (ys)) //=> true
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 …
// gt :: Number -> Number -> Bool
const gt = x => y =>
x > y
// arrayGt :: [a] -> [a] -> Bool
const arrayGt = arrayCompare (gt)
const xs = [5,10,20]
const ys = [2,4,8]
console.log (arrayGt (xs) (ys)) //=> true
// (5 > 2) && (10 > 4) && (20 > 8) //=> true
const zs = [6,12,24]
console.log (arrayGt (xs) (zs)) //=> false
// (5 > 6) //=> false
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 — shallow, deep, strict, loose, some object property, or some arbitrary computation, or any combination of these — all using one procedure, arrayCompare. Maybe even dream up a RegExp comparator ! I know how kids love those regexps …
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 — 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.
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.
Array.prorotype.every. It takes a predicate and the iteration can be stopped early. It is also easy to read provided you know that the passed function has an optional 2nd argument: f => xs => ys => xs.length === ys.length ? xs.every((y, x) => f(x) (ys[y])) : false. I guess the implementation is more memory efficient. It is debatable if this is an idiomatic usage of every though. ys[y] exposes algorithmic details and is less declarative... –
Pemberton .every as you described you have you to flip the x and y parameters – xs.every((x,i) => f (x) (ys[i])). I think it's a useful and idiomatic application of .every but I did want to show how to build a generic higher-order procedure from scratch. Also, I know .length and accessing an array element by index (ys[i]) is not very costly in JavaScript, but I wanted to show that it could be done without either of those too. –
Conventional xs[0], xs.slice(1) but I think it's a safer (and less verbose) pattern than writing your own direct accessors. Thanks for the comment ^_^ –
Conventional arrayCompare? Yes the function is curried, but it differs from some and every. arrayCompare takes a comparator and two arrays to compare. I chose a specifically generic name because we can compare arrays using any arbitrary function. The function is curried so it can be specialised to create new array comparison functions (eg, arrayEqual). Can you suggest a better name? What areas do you feel need additional comments or explanation? I'm happy to discuss ^_^ –
Conventional arrayCompare. "compare" is unfortunately vague since it is used in lots of differerent ways in other contexts: e.g. the C language's qsort function takes a "compar" functor that returns -1,0, or 1 depending on whether the first arg is less than, equal to, or greater than the second; c++'s std::sort takes a "comp" functor that returns true iff the first arg is less than the second, etc. I think if you used some variant of the word "equivalent" instead, it would make it more immediately clear that the intent is to return a bool expressing equivalence. –
Protector ===, ==, !=, >, <, etc are called comparison operators in JavaScript. I understand "comparison" used in a different context (eg sorting) can have a different meaning than the way I'm using "compare" here - though I think both are valid –
Conventional arrayGt in my answer, I think deriving from (eg) arrayEquivalence would feel wrong because gt (>) is not testing for equivalence - hmm. I still wonder if there's a better name altogether. –
Conventional arrayCompare (f, [x,...xs], [y,...xs]) => ... may improve readability for some, but it's just a style difference – the two variants are equivalent when concerning any meaningful factors. Thanks for the comment ^_^ –
Conventional arrayCompare specializes naturally by accepting a higher order function, but also just because I like curried style ^_^ –
Conventional x === undefined && y === undefined which requires you to read backwards to get then it is required to ensure both array iterations yield undefined which means they are of equal length. A length check hidden in the pattern used does require comments. –
Orly 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;
};
true. The answer explains that it won't. If you need to compare nested arrays, you could easily add a recursive check. –
Shericesheridan 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 < this.length; i++) {
if (this[i] instanceof Array && array[i] instanceof Array) {
if (!this[i].equals(array[i], strict))
return false;
}
else if (strict && 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/
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<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<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
.join(); would work as well. Thanks for the insight. –
Craggie checkArrays(): checkArrays([11,22,33,44], [1,12,23,344]) // true –
Leanaleanard .join(). Maybe if you stated your second solution as primary (as it is the better one, though toothless against multidimensional arrays), I would not judge you that way. So far, I downoted all answers that do convert arrays to strings. As well, I upvoted all that use the right way, in case you needed that to know. This means @Tim Down's answer and Bireys one. –
Nazarene checkArrays([1,2,3] , ["1,2",3]) == true, and it's very unlikely that that's what you want to happen! –
Bethel join("~~!!@@##$$%%^^&&**") –
Rasia join() like this makes it subtly buggy! –
Bethel join()ing (ensuring that the individual strings to be joined never contain commas). However given the effort and inefficiency of this approach, you'd be much better off just looping through the array elements! –
Bethel the sort() call will modify the input arrays - this might not be desirable. –
Cwm 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
are_arrs_equal([1,2], [2,1]). Also, see other discussions on this page for why stringifying is unnecessary, fragile, and wrong. –
Delamination are_arrs_equal([1,2], [2,1]) returns true as expected. Perhaps this solution is not ideal, but it worked for me. –
Fowl are_arrs_match(arr1, arr2) . Yes, it doesn't check equality of arrays, but it can say if they contain the same elements. –
Fowl are_arrs_match([1,2], ["1,2"]) (returns true). And note that the sort() call will modify the input arrays - this might not be desirable. –
Cwm 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.
For an array of numbers try:
a1==''+a2
var a1 = [1,2,3];
var a2 = [1,2,3];
console.log( a1==''+a2 )Note: this method will not work when the array also contains strings, e.g. a2 = [1, "2,3"].
You can simply use isEqual from lodash library. It is very efficient and clean.
import isEqual from "lodash/isEqual";
const isTwoArraysEqual = isEqual(array1, array2);
isEqual(sortBy(array1), sortBy(array2)); –
Alfredalfreda 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()).
var a1 = [1,2,3];
var a2 = [1,2,3];
const arraysAreEqual = a1.sort().toString()==a2.sort().toString();
// true if both arrays have same elements else false
console.log(arraysAreEqual);Here you go,
const a = [1, 2, 3]
const b = [1, 2, 3, 4, 5]
const diff = b.filter(e => !a.includes(e))
console.log(diff)Most of the above answers dosen't work for unordered list. This works for unordered lists too.
const a = [3, 2, 1]
const b = [1, 2, 3, 4, 5]
const diff = b.filter(e => !a.includes(e))
console.log(diff)If size of a is greater than b,
const a = [1, 2, 3, 4, 5]
const b = [3, 2, 1]
const diff = a.length > b.length ? a.filter(e => !b.includes(e)) : b.filter(e => !a.includes(e))
console.log(diff)There are many complicated long answers in here, so I just want to contribute one very simple answer: use toString() to turn an array into a simple comma-separated string which you can easily compare with ===
let a = [1, 2, 3]
let b = [1, 2, 3]
let c = [4, 2, 3]
console.log(a.toString()) // this outputs "1,2,3"
console.log(a.toString() === b.toString()) // this outputs true because "1,2,3" === "1,2,3"
console.log(a.toString() === c.toString()) // this outputs false because "1,2,3" != "4,2,3"
1,2,3 !== 3,2,1. So maybe you need to sort the arrays first. –
Mameluke [1, 2, 3].toString() === [1, "2,3"].toString() is true. –
Stipendiary Lot of good answers here. This is how I usually do it -
if ( arr1.length === arr2.length && arr1.every((a1) => arr2.includes(a1)) ) {
// logic
}
every()will only return true if all elements pass the given camparison logic. If it encounters a false, in any iteration, it terminates and returns false.Time complexity will be O(n*m).
There are plenty of answers showing how to compare arrays efficiently.
Below is the shortest way to compare two int or (string) arrays, measured in bytes of code.
const a = [1, 2, 3]
const b = [1, 2, 3]
console.log("1. ", a.join() == b.join())
console.log("2. ", a.join() == [].join())
console.log("3. ", 1 + a == 1 + b)
console.log("4. ", 1 + [] == 1 + b)
// even shorter
console.log("4. b) ", a == "" + b)
// false positives (see flaws)
console.log("5. ", 1 + ["3"] == 1 + [3]) // type differences
console.log("6. ", 1 + ["1,2"] == 1 + ["1", "2"])This works because when using the + operator, the types are automatically converted to allow concatenation. In this case, the 1 and the [1, 2, 3] are both converted to a string.
Internally, JavaScript uses [1, 2, 3].join() to convert the array to a string and then adds them resulting in 11,2,3. When doing this on both arrays, one can simply use === or == to compare the two strings.
Using this technique, the comparison does not care if the elements in the arrays to be compared are of different types. [1, 2] will be equal to ["1", "2"] because of the string conversion.
EDIT: As pointed out in the comments, comparing string arrays can produce false positives, such as ["1,2"] being 'equal' to ["1", "2"]. This is of no concern if you are sure these never occur (e.g. in many code golfing challenges).
While this is useful for code golfing, it should probably not be used in production code. The two flaws pointed out aren't helping that either.
1+["1","2,3"]===1+["1,2","3"] and ["1","2,3"].join()===["1,2","3"].join() (so you can indicate that your answer works for numbers only) –
Picro Here is a Typescript version:
//https://mcmap.net/q/37117/-how-to-check-if-two-arrays-are-equal-with-javascript-duplicate
export function arraysEqual<T>(a: Array<T>, b: Array<T>): 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 < a.length; ++i) {
if (a[i] !== b[i]) return false
}
return true
}
//https://mcmap.net/q/37117/-how-to-check-if-two-arrays-are-equal-with-javascript-duplicate
export function arraysDeepEqual<T>(a: Array<T>, b: Array<T>): 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)
})
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 "devote time to examining the problem space, solutions and cross-cutting concerns". If it makes it to stage 2, it has a good chance of eventually being integrated into the language proper.
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
[11]. Pretty obvious as to why this happens and how to fix. –
Sontag [1,2] and ["1,2"]. –
Cwm a[0] !== b[0]. Have you compared your approach against a classic iteration for example? Besides OP didn't exactly rule out things like objects or nested arrays. Here's an example where serialisation would fail: [{a:1}].join('') === [{b:2}].join('') –
Maddalena Another approach with very few code (using Array reduce and Array includes):
arr1.length == arr2.length && arr1.reduce((a, b) => a && arr2.includes(b), true)
If you want to compare also the equality of order:
arr1.length == arr2.length && arr1.reduce((a, b, i) => a && 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.
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) => 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
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;
}
A simple approach:
function equals(a, b) {
if ((a && !b) || (!a && b) || (!a && !b) || (a.length !== b.length)) {
return false;
}
var isDifferent = a.some(function (element, index) {
return element !== b[index];
});
return !isDifferent;
}
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
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
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 => array2.find(item2 => item===item2))
const isInArray2 = array2.every(item => array1.find(item2 => item===item2))
const isSameArray = array1.length === array2.length && isInArray1 && isInArray2
console.log(isSameArray); //true
Simple
type Values = number | string;
/** Not sorted array */
function compare<Values>(a1: Array<Values>, a2: Array<Values>): boolean {
if (a1.length !== a2.length) {
return false;
}
/** Unique values */
const set1 = new Set<Values>(a1);
const set2 = new Set<Values>(a2);
if (set1.size !== set2.size) {
return false;
}
return [...set1].every((value) => [...set2].includes(value));
}
compare([1, 2, 3], [1, 2, 3]); // true
compare([1, 2, 3], [1, 3, 2]); // true
compare([1, 1, 1], [1, 2, 3]); // false
compare([1, 1, 2, 3], [1, 2, 3]); // false
/** Sorted arrays, faster method */
function compareSorted<Values>(a1: Array<Values>, a2: Array<Values>): boolean {
if (a1.length !== a2.length) {
return false;
}
/** Unique values */
const set1 = new Set<Values>(a1);
const set2 = new Set<Values>(a2);
if (set1.size !== set2.size) {
return false;
}
return [...set1].every((value, index) => value === [...set2][index]);
}
compareSorted([1, 2, 3], [1, 2, 3]); // true
compareSorted([1, 2, 3], [1, 3, 2]); // false
compareSorted([1, 1, 1], [1, 2, 3]); // false
compareSorted([1, 1, 2, 3], [1, 2, 3]); // false
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 && y instanceof Array && x.length !== y.length) return false;
if (typeof x === 'object') {
for (var p in x) if (x.hasOwnProperty(p)) {
if (typeof x[p] === 'function' && typeof y[p] === 'function') continue;
if (x[p] instanceof Array && y[p] instanceof Array && x[p].length !== y[p].length) return false;
if (typeof x[p] !== typeof y[p]) return false;
if (typeof x[p] === 'object' && 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.
equal({}, {a:1}) and equal({}, null) and this errors out: equal({a:2}, null) –
Cochard JSON.stringify(collectionNames).includes(JSON.stringify(sourceNames)) ? array.push(collection[i]) : null
This is how i did it.
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) && `${a}`;
const b_string = Array.isArray(b) && `${b}`;
const result = (a === b);
console.log(result);
Taking into consideration you're using ES6 of course.
=)
a = ["1,1", "2"] and b = [1,1,2] (or b = ["1", "1,2"])... I think it will be hard to get something robust with this approach. ^^ –
Cordilleras JSON.stringify won't perform a shallow comparison either. –
Metalware An alternative way using filter and arrow functions
arrOne.length === arrTwo.length && arrOne.filter((currVal, idx) => currVal !== arrTwo[idx]).length === 0
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 <= a2 && a1 >= a2; // true
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 < this.length; i++) {
// Check if we have nested arrays
if (this[i] instanceof Array && 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;
}
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)
Recursive & works on NESTED arrays:
function ArrEQ(a1,a2){
return(
//:Are both elements arrays?
Array.isArray(a1)&&Array.isArray(a2)
?
//:Yes: Test each entry for equality:
a1.every((v,i)=>(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"]]]
));;
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 < (arrays.length-1); i++ ){
var a1 = arrays[i+0];
var a2 = arrays[i+1];
var res =(
//:Are both elements arrays?
Array.isArray(a1)&&Array.isArray(a2)
?
//:Yes: Compare Each Sub-Array:
//:v==a1[i]
a1.every((v,i)=>(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" ]]],
));;
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 => {
if (flag) {
if (!array2.includes(array_obj)) {
flag = false;
}
}
});
// then vice versa check array2 object is available in array1 index
array2.every( array_obj => {
if (flag) {
if (!array1.includes(array_obj)) {
flag = false;
}
}
});
return flag;
} else {
return false;
}
}
Surprisingly, nobody brought up a solution with find
const a = [1, 2, 3]
const b = [1, 2, 3, 4]
a.find((v,i) => v !== b[i])
The benefit here is that instead of comparing all values it looks for the first occurrence and ends the loop as early as possible. Or in other words, instead of asking "are two arrays equal?" it asks "is one array different from another?".
3rd by performance benchmark https://jsben.ch/TgFrA
Keep in mind, the order matters, a.find(...) !== b.find(...) and could be checked by a.length === b.length
if (a.length === b.length && a.find((v,i) => v !== b[i]) === undefined) {
// equal
}
a.find((v,i) => v !== b[i]) is exactly equivalent to a.some((v,i) => v !== b[i]) with the difference that .some() returns a boolean directly. .some() and .every() are also equivalent to each other through negation: a.every((v,i) => v -== b[i]). When I ran the benchmark the .every() code was in second place in front of the .find() variant. –
Cheeky 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) => {
return arr1.length > 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!
All the other solutions look complicated. This might not be the most efficient with or handle all edge cases but it works great for me.
Array.prototype.includesArray = function(arr) {
return this.map(i => JSON.stringify(i)).includes(JSON.stringify(arr))
}
Usage
[[1,1]].includesArray([1,1])
// true
[[1,1]].includesArray([1,1,2])
// false
this script compares Object, Arrays and multidimensional array
function compare(a,b){
var primitive=['string','number','boolean'];
if(primitive.indexOf(typeof a)!==-1 && 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
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<a1.length; i++) {
if (Array.isArray(a1[i]) && Array.isArray(a2[i])) {
if (equals(a1[i], a2[i])) {
continue;
} else {
return false;
}
} else {
if (a1[i] !== a2[i]) {
return false;
}
}
}
return true;
}
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) > -1;
}
});
}
Récursive cmp function working with number/string/array/object
<script>
var cmp = function(element, target){
if(typeof element !== typeof target)
{
return false;
}
else if(typeof element === "object" && (!target || !element))
{
return target === element;
}
else if(typeof element === "object")
{
var keys_element = Object.keys(element);
var keys_target = Object.keys(target);
if(keys_element.length !== keys_target.length)
{
return false;
}
else
{
for(var i = 0; i < keys_element.length; i++)
{
if(keys_element[i] !== keys_target[i])
return false;
if(!cmp(element[keys_element[i]], target[keys_target[i]]))
return false;
}
return true;
}
}
else
{
return element === target;
}
};
console.log(cmp({
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", false, null, {v:1}]}]
}, {
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", false, null, {v:1}]}]
})); // true
console.log(cmp({
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", false, null, {v:1}]}]
}, {
key1: 3,
key2: "string",
key3: [4, "45", {key4: [5, "6", undefined, null, {v:1}]}]
})); // false
</script>This method is one that only works on scalar arrays, like the second voted answer on this question.
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) => (one.filter((i, n) => two[n] === i).length === one.length) && (two.filter((i, n) => one[n] === i).length === two.length)
arrs.forEach(arr => {
console.log(arraysEqual(arr[0], arr[1]))
})Without ES6 syntax:
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) => two[n] === i).length === one.length) && (two.filter((i, n) => one[n] === i).length === two.length)
}
arrs.forEach(arr => {
console.log(arraysEqual(arr[0], arr[1]))
})I answered this question at https://mcmap.net/q/37117/-how-to-check-if-two-arrays-are-equal-with-javascript-duplicate (which has since been marked a duplicate of this answer). There you will find a Deep Equals implementation that handles numerous cases, such as Map and Set and arbitrary nesting of arrays and objects. The discussion therein of non-transitivity of == and documenting == vs === is particularly important.
For OP's particular problem, if the arrays consist only of numbers and strings and booleans, and no NaNs, then the most efficient method for sufficiently large arrays is a precompiled function:
function areSimpleArraysEqual(a,b) {
// requires inputs be arrays of only Number, String, Boolean, and no NaN.
// will propagate error if either array is undefined.
if (a.length!=b.length)
return false;
for(let i=0; i<a.length; i++)
if (a[i]!==b[i]) // using === equality
return false;
return true;
}
One may achieve average-case O(1) and worst-case O(N) in some rare instances if one's business logic keeps appending to the ends of the arrays, by also checking if (a.length>0 && a[a.length-1]!==b[b.length-1]) return false; .
If you like simple savagery:
const a1 = ['a', 'b', 'e', 'd', 'c'];
const a2 = ['a', 'b', 'c', 'd', 'e'];
a1.length === a2.length && [...a1, ...a2].filter((item) => a2.indexOf(item) === -1).length === 0
Note that you can perform "indexOf" on any of the 2 arrays.
indexOf(item) === -1 fell out of favor when ! includes(item) was introduced in 2016. –
Tribesman 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;
}
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
Array.prototype.reduce will walk through every element in a even if the first compared elements do not match. Also using !a and != in the loop is a double negative which makes this answer more complicated (and hard to read) than it needs to be –
Conventional 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});
let equals = (LHS, RHS) => {
if (!(LHS instanceof Array)) return "false > L.H.S is't an array";
if (!(RHS instanceof Array)) return "false > R.H.S is't an array";
if (LHS.length != RHS.length) return false;
let to_string = x => JSON.stringify(x.sort((a, b) => 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
Here's a CoffeeScript version, for those who prefer that:
Array.prototype.equals = (array) ->
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.
I would do like this:
[2,3,4,5] == [2,3,4,5].toString()
When you use the "==" operator, JavaScript checks 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 uses 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()
[1,2,3,4].toString() === ["1,2,3",4].toString() // => true –
Conventional © 2022 - 2024 — McMap. All rights reserved.
JSON.parsewould also iterate through each value anyway so I guess it would be better to compare iterating through each value and reduce some steps of execution ( like encoding it into JSON ). – Allay([] == []) == false. – Recapitulate[1, 2].join() === [1, 2].join()– Fraughtif (a1.length!==a2.length || JSON.stringify(a1)!==JSON.stringify(a2)) { /* something is different */ }– Bantuisand==, which do "what you'd expect them to do," one checks reference equality, and the other uses either built-in or overloaded comparison. In my opinion it's far more intuitive and useful than the js state of affairs. – Troytroyer#[1, 2, 3] === #[1, 2, 3]. – Pennyworth[1,2,3] == [1,2,3] # returns true. I guess it just comes down to understanding the nuances of each language. – Sogdiana([] == []) == True. "In C++, you'd be comparing two pointers - false." You mean in C. Sure, C++ supports C arrays, but in C++std::vectors are more common and more useful, and(std::vector<T>() == std::vector<T>()) == true. – Stipendiarystd::arraywas not in wide use back then (although it is C++11 thing), and I generally did not considervectoran array because that was kinda reserved for C style arrays. Notably,std::arrayalso has a==operator so if you're writing modern C++, my comment is indeed not valid in that sense. But dude... it's 10 years ago. I literally went through 2 jobs, 3 relationships and 3 mortage refinances... – Nazarenestd::vectorto be the C++ equivalent of JavaScript arrays though. They might not have the same name, but the features supported by JavaScript arrays are more similar to those supported bystd::vectorthan those supported bystd::arrayor C arrays. – Stipendiary