我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
这个方法只适用于标量数组，就像这个问题的第二个投票答案一样。
变量arrs=[[[1，2，3]，[1，2，3]]，//真[[1，2，3，4]，[1，2，3]，//错误[[1，2，3]，[1，2，3，4]]，//错误]常量数组相等=（一，二）=>（一个滤波器（（i，n）=>两个[n]==i）。长度==一个长度）&&（两个滤波器（i，n）=>一个[n]==i）。长==两个长度）arrs.forEach（arr=>{console.log（arraysEqual（arr[0]，arr[1]））})
没有ES6语法：
变量arrs=[[[1，2，3]，[1，2，3]]，//真[[1，2，3，4]，[1，2，3]，//错误[[1，2，3]，[1，2，3，4]]，//错误]函数arraysEqual（一，二）{return（one.filter（（i，n）=>two[n]==i）.length==one.length）&&（two.filter}arrs.forEach（arr=>{console.log（arraysEqual（arr[0]，arr[1]））})
其他回答
选择是否比较订单：
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;
}
});
}
我在回答这个问题https://stackoverflow.com/a/10316616/711085（此后已标记为该答案的副本）。在那里，您将发现一个DeepEquals实现，它处理许多情况，例如Map和Set以及数组和对象的任意嵌套。其中对==的非传递性和记录==vs==的讨论尤为重要。
对于OP的特殊问题，如果数组仅由数字、字符串和布尔值组成，而没有NaN，那么对于足够大的数组，最有效的方法是预编译函数：
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;
}
如果一个人的业务逻辑一直附加到数组的末尾，通过检查（a.length>0&&a[a.length-1]！==b[b.length-1]）是否返回false；，在一些罕见的情况下，可以实现平均情况O（1）和最坏情况O（N）。
这将比较2个未排序的数组：
function areEqual(a, b) {
if ( a.length != b.length) {
return false;
}
return a.filter(function(i) {
return !b.includes(i);
}).length === 0;
}
根据TomášZato的回答，我同意仅迭代数组是最快的。此外（就像其他人已经说过的那样），函数应该被称为equals/equal，而不是compare。考虑到这一点，我修改了该函数，以处理比较数组的相似性（即它们具有相同的元素，但没有顺序），以供个人使用，并认为我将把它放在这里让大家看到。
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;
}
此函数接受默认为true的strict附加参数。这个严格的参数定义数组是否需要在内容和这些内容的顺序上完全相等，或者仅仅包含相同的内容。
例子：
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
我还编写了一个函数的快速jsfiddle，以及这个示例：http://jsfiddle.net/Roundaround/DLkxX/
我喜欢将Undercore库用于数组/对象密集型编码项目。。。在Undercore和Lodash中，无论您是比较数组还是对象，它看起来都是这样的：
_.isEqual(array1, array2) // returns a boolean
_.isEqual(object1, object2) // returns a boolean
Undercore is Equal文档Lodash isEqual文档
