我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
我的解决方案比较对象，而不是数组。这将以与Tomáš相同的方式工作，因为数组是对象，但没有警告：
Object.prototype.compare_to = function(comparable){
// Is the value being compared an object
if(comparable instanceof Object){
// Count the amount of properties in @comparable
var count_of_comparable = 0;
for(p in comparable) count_of_comparable++;
// Loop through all the properties in @this
for(property in this){
// Decrements once for every property in @this
count_of_comparable--;
// Prevents an infinite loop
if(property != "compare_to"){
// Is the property in @comparable
if(property in comparable){
// Is the property also an Object
if(this[property] instanceof Object){
// Compare the properties if yes
if(!(this[property].compare_to(comparable[property]))){
// Return false if the Object properties don't match
return false;
}
// Are the values unequal
} else if(this[property] !== comparable[property]){
// Return false if they are unequal
return false;
}
} else {
// Return false if the property is not in the object being compared
return false;
}
}
}
} else {
// Return false if the value is anything other than an object
return false;
}
// Return true if their are as many properties in the comparable object as @this
return count_of_comparable == 0;
}
其他回答
这个方法只适用于标量数组，就像这个问题的第二个投票答案一样。
变量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]））})
尽管这有很多答案，但我相信这会有所帮助：
const newArray = [ ...new Set( [...arr1, ...arr2] ) ]
这个问题中没有说明数组的结构是什么样子的，所以如果你确定你的数组中既没有嵌套的数组也没有对象（这发生在我身上，这就是我得到这个答案的原因），上面的代码就会起作用。
发生的情况是，我们使用扩展运算符（…）将两个数组合并，然后使用Set消除任何重复。一旦你有了这些，你就可以比较它们的大小，如果三个数组都有相同的大小，那么你就可以去做了。
这个答案也忽略了元素的顺序，正如我所说的，确切的情况发生在我身上，所以也许有人在同样的情况下会在这里结束（正如我所做的那样）。
编辑1。
回答德米特里·格林科的问题：“你为什么在这里使用扩展运算符（…）-……新设置？它不起作用”
考虑以下代码：
const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ new Set( [...arr1, ...arr2] ) ]
console.log(newArray)
你会得到
[ Set { 'a', 'b', 'c' } ]
为了使用该值，您需要使用一些Set财产（请参见https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).另一方面，当您使用此代码时：
const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ ...new Set( [...arr1, ...arr2] ) ]
console.log(newArray)
你会得到
[ 'a', 'b', 'c' ]
这就是区别，前者会给我一个集合，它也会工作，因为我可以得到集合的大小，但后者给了我所需的数组，更直接的是分辨率。
如果使用Mocha这样的测试框架和Chai断言库，可以使用深度相等来比较数组。
expect(a1).to.deep.equal(a2)
只有当数组在相应的索引处具有相等的元素时，才会返回true。
尝试了深度平等，并且成功了
var eq = require('deep-equal');
eq({a: 1, b: 2, c: [3, 4]}, {c: [3, 4], a: 1, b: 2});
虽然这只适用于标量数组（请参见下面的注释），但代码很短：
array1.length === array2.length && array1.every(function(value, index) { return value === array2[index]})
与上文相同，但在ECMAScript 6/CoffeeScript/TypeScript中使用箭头函数：
array1.length === array2.length && array1.every((value, index) => value === array2[index])
（注意：这里的“scalar”表示可以使用==直接比较的值。因此：数字、字符串、引用对象、引用函数。有关比较运算符的更多信息，请参阅MDN引用）。
更新
根据我在评论中看到的内容，对数组进行排序和比较可能会得到准确的结果：
const array2Sorted = array2.slice().sort();
array1.length === array2.length && array1.slice().sort().every(function(value, index) {
return value === array2Sorted[index];
});
Eg:
array1 = [2,3,1,4];
array2 = [1,2,3,4];
然后上述代码将返回true
