我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
所有其他解决方案看起来都很复杂。这可能不是处理所有边缘情况的最有效方法，但它对我来说非常有用。
Array.prototype.includesArray = function(arr) {
return this.map(i => JSON.stringify(i)).includes(JSON.stringify(arr))
}
用法
[[1,1]].includesArray([1,1])
// true
[[1,1]].includesArray([1,1,2])
// false
其他回答
此外，我还根据需要将Thomas的解决方案转换为无需排序的比较。
Array.prototype.equalsFreeOrder = function (array) {
var isThisElemExist;
if (!array)
return false;
if (this.length != array.length)
return false;
for (var i = 0; i < this.length; i++) {
isThisElemExist = false;
for (var k = 0; k < this.length; k++) {
if (this[i] instanceof Array && array[k] instanceof Array) {
if (this[i].equalsFreeOrder(array[k]))
isThisElemExist = true;
}
else if (this[i] == array[k]) {
isThisElemExist = true;
}
}
if (!isThisElemExist)
return false;
}
return true;
}
我在回答这个问题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）。
与JSON.encode相同的行是使用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
唯一的问题是，如果您关心上次比较测试的类型。如果你关心类型，你将不得不循环。
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
如果顺序应该保持不变，而不是循环，则不需要排序。
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
尝试了深度平等，并且成功了
var eq = require('deep-equal');
eq({a: 1, b: 2, c: [3, 4]}, {c: [3, 4], a: 1, b: 2});
这里有很多好答案。我通常是这样做的-
if ( arr1.length === arr2.length && arr1.every((a1) => arr2.includes(a1)) ) {
// logic
}
every（）只在所有元素都通过给定的camparison时返回true思维方式如果在任何迭代中遇到错误，它将终止并返回false。时间复杂度为O（n*m）。
