我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
我在回答这个问题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）。
其他回答
我想出了另一种方法。使用join（“”）将它们更改为字符串，然后比较两个字符串：
var a1_str = a1.join(''),
a2_str = a2.join('');
if (a2_str === a1_str) {}
与嵌套数组一起使用MULTIPLE参数：
//:Return true if all of the arrays equal.
//:Works with nested arrays.
function AllArrEQ(...arrays){
for(var i = 0; i < (arrays.length-1); i++ ){
var a1 = arrays[i+0];
var a2 = arrays[i+1];
var res =(
//:Are both elements arrays?
Array.isArray(a1)&&Array.isArray(a2)
?
//:Yes: Compare Each Sub-Array:
//:v==a1[i]
a1.every((v,i)=>(AllArrEQ(v,a2[i])))
:
//:No: Simple Comparison:
(a1===a2)
);;
if(!res){return false;}
};;
return( true );
};;
console.log( AllArrEQ(
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
[1,2,3,[4,5,[6,"ALL_EQUAL" ]]],
));;
我的解决方案比较对象，而不是数组。这将以与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;
}
虽然这个问题的最佳答案是正确和良好的，但提供的代码可能需要一些改进。
下面是我自己比较数组和对象的代码。代码简短而简单：
Array.prototype.equals = function(otherArray) {
if (!otherArray || this.length != otherArray.length) return false;
return this.reduce(function(equal, item, index) {
var otherItem = otherArray[index];
var itemType = typeof item, otherItemType = typeof otherItem;
if (itemType !== otherItemType) return false;
return equal && (itemType === "object" ? item.equals(otherItem) : item === otherItem);
}, true);
};
if(!Object.prototype.keys) {
Object.prototype.keys = function() {
var a = [];
for (var key in this) {
if (this.hasOwnProperty(key)) a.push(key);
}
return a;
}
Object.defineProperty(Object.prototype, "keys", {enumerable: false});
}
Object.prototype.equals = function(otherObject) {
if (!otherObject) return false;
var object = this, objectKeys = object.keys();
if (!objectKeys.equals(otherObject.keys())) return false;
return objectKeys.reduce(function(equal, key) {
var value = object[key], otherValue = otherObject[key];
var valueType = typeof value, otherValueType = typeof otherValue;
if (valueType !== otherValueType) return false;
// this will call Array.prototype.equals for arrays and Object.prototype.equals for objects
return equal && (valueType === "object" ? value.equals(otherValue) : value === otherValue);
}, true);
}
Object.defineProperty(Object.prototype, "equals", {enumerable: false});
此代码支持嵌套在对象中的数组和嵌套在数组中的对象。
您可以在下面的repl中看到一整套测试并自己测试代码：https://repl.it/Esfz/3
您可以简单地使用lodash库中的isEqual。它非常高效和干净。
import isEqual from "lodash/isEqual";
const isTwoArraysEqual = isEqual(array1, array2);
