我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
此函数比较两个任意形状和尺寸的数组：
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;
}
其他回答
所有其他解决方案看起来都很复杂。这可能不是处理所有边缘情况的最有效方法，但它对我来说非常有用。
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
代码高尔夫
有很多答案表明如何有效地比较数组。
以下是比较两个int或（字符串）数组的最短方法，以代码字节为单位。
常量a=[1，2，3]常量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）//甚至更短console.log（“4.b）”，a==“”+b）//误报（见缺陷）console.log（“5.”，1+[“3”]==1+[3]）//类型差异console.log（“6.”，1+[“1,2”]==1+[“1”，“2”]）
解释
这是因为当使用+运算符时，类型会自动转换为允许串联。在这种情况下，1和[1，2，3]都被转换为字符串。
在内部，JavaScript使用[1，2，3].join（）将数组转换为字符串，然后将它们相加，得到11，2，3。在两个数组上执行此操作时，可以简单地使用==或==来比较两个字符串。
缺陷
使用此技术，比较不关心要比较的数组中的元素是否属于不同类型。由于字符串转换，[1，2]将等于[“1”，“2”]。
编辑：正如评论中指出的，比较字符串数组可能会产生误报，例如[“1,2”]等于[“1”，“2”]。如果您确信这些情况从未发生过（例如，在许多代码高尔夫挑战中），这一点就不重要了。
免责声明
虽然这对于代码高尔夫很有用，但可能不应该在生产代码中使用。指出的两个缺陷也无助于此。
尝试了深度平等，并且成功了
var eq = require('deep-equal');
eq({a: 1, b: 2, c: [3, 4]}, {c: [3, 4], a: 1, b: 2});
与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
本着原问题的精神：
我想比较两个数组。。。理想地、有效地。没有什么想象，如果它们是相同的，则为真，如果不是，则为假。
我一直在对这里提出的一些更简单的建议进行性能测试，结果如下（从快到慢）：
而Tim Down（67%）
var i = a1.length;
while (i--) {
if (a1[i] !== a2[i]) return false;
}
return true
每（69%）用户2782196
a1.every((v,i)=> v === a2[i]);
DEI减少（74%）
a1.reduce((a, b) => a && a2.includes(b), true);
Gaizka Allende&vivek的join&toString（78%）
a1.join('') === a2.join('');
a1.toString() === a2.toString();
Victor Palomo创作的半到字符串（90%）
a1 == a2.toString();
radtek的stringify（100%）
JSON.stringify(a1) === JSON.stringify(a2);
注意，下面的示例假设数组是排序的，一维数组。对于一个常见的基准测试，长度比较已被删除（将a1.length==a2.length添加到任何建议中，您将获得约10%的性能提升）。选择最适合您的解决方案，了解每种解决方案的速度和局限性。
