I have an array of arrays, which looks something like this:
[["Some string", "Some other string"],["Some third string", "some fourth string"]]
I think I can use the _.all method in Underscore to determine if all of the arrays match 100% (that is all of their values match), but I'm not sure how to write the required iterator to run the check.
Anyone have an idea?
Why not intersection? (if you really want to use some Underscore functions for this) http://underscorejs.org/#intersection
If the arrays are of the same length, and the length of the intersection equals to the length of the arrays, then they all contain the same values.
My preference:
_.isEqual(_.sortBy(first), _.sortBy(second))
And if order matters:
_(first).isEqual(second)
Try this guy (order-independent):
function allArraysAlike(arrays) {
return _.all(arrays, function(array) {
return array.length == arrays[0].length && _.difference(array, arrays[0]).length == 0;
});
}
This is assuming you want all of the arrays to contain all the same elements in the same order as one another (so for your example input the function should return false).
_.difference only checks if the values of the first array are not present in the second array; additional values in the second array are not detected; if you really want to make sure that both arrays are the same you should do _.difference(array, arrays[0]).length == 0 && _.difference(array[0], arrays).length == 0
allArraysAlike( [ [0,1] , [0,0] ] ) = trueUse underscore to determine the difference between the two, and check the length of the array. An easy way to do this would be:
_.isEmpty(_.difference(array1, array2)) && _.isEmpty(_.difference(array2, array1))
This will return true if they are the same and false if they are not.
_.isEmpty(_.xor(array1, array2))
My implementation with http://underscorejs.org/
/**
* Returns true if the arrays are equal
*
* @param {Array} array1
* @param {Array} array2
* @returns {boolean}
*/
equal: function ( array1, array2 )
{
return ( array1.length === array2.length)
&& (array1.length === _.intersection( array1, array2 ).length);
}
If you want to check that the elements are the same and in the same order, I would go with:
arrayEq = function(a, b) {
return _.all(_.zip(a, b), function(x) {
return x[0] === x[1];
});
};
Even more neatly in coffeescript:
arrayEq = (a,b) ->
_.all _.zip(a,b), (x) -> x[0]==x[1]
return _.union(x).length == 1; for arbitrary numbers of arrays compared.
_.isEqual.If you don't need to know which elements are unequal, use transitivity:
function allEqual(list) {
return _.all(list.slice(1), _.partial(_.isEqual, list[0]));
}
allEqual([2, 2, 2, 2]) //=> true
allEqual([2, 2, 3, 2]) //=> false
allEqual([false]) //=> true
allEqual([]) //=> true
I can't comment on Dan Tao's answer, small change to skip checking of first array against itself (unnecessary _.difference call)
function allArraysAlike(arrays) {
return _.all(arrays, function(array) {
if(array === arrays[0]) return true;
return array.length == arrays[0].length && _.difference(array, arrays[0]).length == 0;
});
}
a = [1, ... x]; b = a; allArraysAlike([a, b]) 
