我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
易于理解的
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
其他回答
此函数比较两个任意形状和尺寸的数组：
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;
}
与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
不清楚你所说的“相同”是什么意思。例如，下面的数组a和b是否相同（请注意嵌套数组）？
var a = ["foo", ["bar"]], b = ["foo", ["bar"]];
这里有一个优化的数组比较函数，它使用严格的相等性依次比较每个数组的对应元素，并且不递归比较本身为数组的数组元素，这意味着对于上面的示例，arraysIncore（a，b）将返回false。它适用于一般情况，而基于JSON和join（）的解决方案不会：
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;
};
另一种代码很少的方法（使用Array reduce和Array includes）：
arr1.length == arr2.length && arr1.reduce((a, b) => a && arr2.includes(b), true)
如果还要比较顺序的相等性：
arr1.length == arr2.length && arr1.reduce((a, b, i) => a && arr2[i], true)
长度检查确保一个数组中的元素集不仅仅是另一个数组的子集。缩减器用于遍历一个数组并搜索另一个数组中的每个项。如果找不到一项，reduce函数将返回false。在第一个示例中，正在测试是否包含元素第二个示例也检查订单
递归在NESTED数组上工作（&W）：
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"]]]
));;
