我想比较两个数组。。。理想地、有效地。没有什么稀奇古怪的，如果它们是相同的，那就是真的，如果不是，那就是假的。毫不奇怪，比较运算符似乎不起作用。
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对每个数组进行编码，但是否有一种更快或“更好”的方法来简单地比较数组而不必遍历每个值？
当前回答
使用数字/字符串/数组/对象的Ré草书cmp函数
<脚本>var cmp=函数（元素，目标）{if（元素类型！==目标类型）{return false；}否则if（typeof element==“object”&&（！target||！element））{返回目标==元素；}else if（元素类型==“对象”）{var keys_element=对象.keys（元素）；var keys_target=对象.keys（目标）；如果（keys_element.length！==keys_target.length）{return false；}其他的{对于（var i=0；i<keys_element.length；i++）{如果（keys_element[i]！==keys_target[i]）return false；if（！cmp（元素[keys_element[i]]，目标[keys_target[i]]））return false；}返回true；}}其他的{返回元素==目标；}};console.log（cmp({键1：3，key2:“字符串”，key3:[4，“45”，｛key4:[5，“6”，false，null，｛v:1｝]｝]}, {键1：3，key2:“字符串”，key3:[4，“45”，｛key4:[5，“6”，false，null，｛v:1｝]｝]})); // 真的console.log（cmp({键1：3，key2:“字符串”，key3:[4，“45”，｛key4:[5，“6”，false，null，｛v:1｝]｝]}, {键1：3，key2:“字符串”，键3:[4，“45”，｛键4:[5，“6”，未定义，null，｛v:1｝]｝]})); // 假的</script>
其他回答
这里有很多复杂的长答案，所以我只想提供一个非常简单的答案：使用toString（）将数组转换为简单的逗号分隔字符串===
let a = [1, 2, 3]
let b = [1, 2, 3]
let c = [4, 2, 3]
console.log(a.toString()) // this outputs "1,2,3"
console.log(a.toString() === b.toString()) // this outputs true because "1,2,3" === "1,2,3"
console.log(a.toString() === c.toString()) // this outputs false because "1,2,3" != "4,2,3"
我在回答这个问题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）。
实用的方法
我认为将特定的实现称为“正确的方式”是错误的™Tomáš的解决方案是对基于字符串的数组比较的明显改进，但这并不意味着它客观上“正确”“。到底什么是正确的？它是最快的？它最灵活吗？它最容易理解吗？它是调试最快的吗？它使用最少的操作吗？它有任何副作用吗？没有一个解决方案可以拥有所有事情中最好的。
Tomáš’s可以说他的解决方案很快，但我也可以说这是不必要的复杂。它试图成为一个适用于所有阵列（无论是否嵌套）的一体化解决方案。事实上，它甚至不仅仅接受数组作为输入，还试图给出一个“有效”的答案。
泛型提供可重用性
我的回答将以不同的方式处理这个问题。我将从一个通用的arrayCompare过程开始，该过程只涉及遍历数组。然后，我们将构建其他基本的比较函数，如arrayEqual和arrayDeepEqual等
// arrayCompare :: (a -> a -> Bool) -> [a] -> [a] -> Bool
const arrayCompare = f => ([x,...xs]) => ([y,...ys]) =>
x === undefined && y === undefined
? true
: Boolean (f (x) (y)) && arrayCompare (f) (xs) (ys)
在我看来，最好的代码甚至不需要注释，这也不例外。这里发生的事情太少了，你几乎可以毫不费力地理解这个过程的行为。当然，现在ES6的一些语法对您来说可能是陌生的，但这只是因为ES6相对较新。
正如类型所示，arrayCompare采用比较函数f和两个输入数组xs和ys。大多数情况下，我们所做的就是为输入数组中的每个元素调用f（x）（y）。如果用户定义的f返回false，我们将返回一个早期的false，这要归功于&&的短路评估。因此，是的，这意味着比较器可以提前停止迭代，并在不必要时防止循环通过输入数组的其余部分。
严格的比较
接下来，使用arrayCompare函数，我们可以轻松地创建其他可能需要的函数。我们将从基本数组Equal开始…
// equal :: a -> a -> Bool
const equal = x => y =>
x === y // notice: triple equal
// arrayEqual :: [a] -> [a] -> Bool
const arrayEqual =
arrayCompare (equal)
const xs = [1,2,3]
const ys = [1,2,3]
console.log (arrayEqual (xs) (ys)) //=> true
// (1 === 1) && (2 === 2) && (3 === 3) //=> true
const zs = ['1','2','3']
console.log (arrayEqual (xs) (zs)) //=> false
// (1 === '1') //=> false
就这么简单。arrayEqual可以用arrayCompare和一个比较器函数来定义，该函数使用==（用于严格相等）来比较a和b。
注意，我们还将equal定义为它自己的函数。这突出了arrayCompare作为在另一种数据类型（Array）的上下文中使用一阶比较器的高阶函数的作用。
松散的比较
我们可以使用==来定义arrayLooseEqual。现在，当比较1（数字）和“1”（字符串）时，结果将为真…
// looseEqual :: a -> a -> Bool
const looseEqual = x => y =>
x == y // notice: double equal
// arrayLooseEqual :: [a] -> [a] -> Bool
const arrayLooseEqual =
arrayCompare (looseEqual)
const xs = [1,2,3]
const ys = ['1','2','3']
console.log (arrayLooseEqual (xs) (ys)) //=> true
// (1 == '1') && (2 == '2') && (3 == '3') //=> true
深度比较（递归）
你可能已经注意到这只是一个肤浅的比较。当然，Tomáš的解决方案是“正确的道路”™“因为它隐含着深刻的对比，对吧？”？
我们的arrayCompare程序非常通用，可以轻松地进行深度平等测试…
// isArray :: a -> Bool
const isArray =
Array.isArray
// arrayDeepCompare :: (a -> a -> Bool) -> [a] -> [a] -> Bool
const arrayDeepCompare = f =>
arrayCompare (a => b =>
isArray (a) && isArray (b)
? arrayDeepCompare (f) (a) (b)
: f (a) (b))
const xs = [1,[2,[3]]]
const ys = [1,[2,['3']]]
console.log (arrayDeepCompare (equal) (xs) (ys)) //=> false
// (1 === 1) && (2 === 2) && (3 === '3') //=> false
console.log (arrayDeepCompare (looseEqual) (xs) (ys)) //=> true
// (1 == 1) && (2 == 2) && (3 == '3') //=> true
就这么简单。我们使用另一个高阶函数构建了一个深度比较器。这次我们使用一个自定义比较器包装arrayCompare，该比较器将检查a和b是否为数组。如果是，请重新应用arrayDeepCompare，否则将a和b与用户指定的比较器（f）进行比较。这允许我们将深度比较行为与实际比较单个元素的方式分开。也就是说，正如上面的例子所示，我们可以使用equal、looseEqual或我们制作的任何其他比较器进行深度比较。
因为arrayDeepCompare是currized的，所以我们也可以像前面的示例一样部分应用它
// arrayDeepEqual :: [a] -> [a] -> Bool
const arrayDeepEqual =
arrayDeepCompare (equal)
// arrayDeepLooseEqual :: [a] -> [a] -> Bool
const arrayDeepLooseEqual =
arrayDeepCompare (looseEqual)
对我来说，这已经比Tomáš的解决方案有了明显的改进，因为我可以根据需要为阵列明确选择浅比较或深比较。
对象比较（示例）
现在，如果您有一个对象数组或其他东西呢？如果每个对象都具有相同的id值，那么您可能希望将这些数组视为“相等”…
// idEqual :: {id: Number} -> {id: Number} -> Bool
const idEqual = x => y =>
x.id !== undefined && x.id === y.id
// arrayIdEqual :: [a] -> [a] -> Bool
const arrayIdEqual =
arrayCompare (idEqual)
const xs = [{id:1}, {id:2}]
const ys = [{id:1}, {id:2}]
console.log (arrayIdEqual (xs) (ys)) //=> true
// (1 === 1) && (2 === 2) //=> true
const zs = [{id:1}, {id:6}]
console.log (arrayIdEqual (xs) (zs)) //=> false
// (1 === 1) && (2 === 6) //=> false
就这么简单。这里我使用了普通的JS对象，但这种类型的比较器可以适用于任何对象类型；甚至您的自定义对象。Tomáš的解决方案需要彻底修改，以支持这种平等测试
有对象的深度阵列？没问题。我们构建了高度通用的通用函数，因此它们可以在各种各样的用例中工作。
const xs = [{id:1}, [{id:2}]]
const ys = [{id:1}, [{id:2}]]
console.log (arrayCompare (idEqual) (xs) (ys)) //=> false
console.log (arrayDeepCompare (idEqual) (xs) (ys)) //=> true
任意比较（示例）
或者如果你想做一些其他的完全武断的比较呢？也许我想知道每个x是否大于每个y…
// gt :: Number -> Number -> Bool
const gt = x => y =>
x > y
// arrayGt :: [a] -> [a] -> Bool
const arrayGt = arrayCompare (gt)
const xs = [5,10,20]
const ys = [2,4,8]
console.log (arrayGt (xs) (ys)) //=> true
// (5 > 2) && (10 > 4) && (20 > 8) //=> true
const zs = [6,12,24]
console.log (arrayGt (xs) (zs)) //=> false
// (5 > 6) //=> false
少就是多
你可以看到我们实际上在用更少的代码做更多的事情。arrayCompare本身并不复杂，我们制作的每个自定义比较器都有一个非常简单的实现。
很容易，我们可以精确地定义我们希望如何比较两个数组-浅数组、深数组、严格数组、松散数组、一些对象属性、一些任意计算，或者它们的任意组合-所有这些都使用一个过程arrayCompare。甚至可以梦想一个RegExp比较器！我知道孩子们多么喜欢这些正则表达式…
它是最快的吗？不。但它可能也不需要。如果速度是衡量代码质量的唯一标准，那么很多真正优秀的代码就会被丢弃——这就是为什么我将这种方法称为实用方法。或者更公平地说，一种实用的方式。这个描述适合这个答案，因为我并不是说这个答案与其他答案相比只实用；这在客观上是正确的。我们用非常简单的代码实现了高度的实用性。没有其他代码可以说明我们没有获得此描述。
这是否是您的“正确”解决方案？这由你决定。没有人能为你做到这一点；只有你知道你的需求是什么。在几乎所有情况下，我都看重简单、实用和通用的代码，而不是聪明和快速的代码。你看重的可能不同，所以选择适合你的。
Edit
我以前的答案更侧重于将arrayEqual分解为小程序。这是一个有趣的练习，但并不是解决这个问题的最佳（最实用）方法。如果您感兴趣，可以查看此修订历史记录。
要比较数组，请循环它们并比较每个值：
比较阵列：
// Warn if overriding existing method
if(Array.prototype.equals)
console.warn("Overriding existing Array.prototype.equals. Possible causes: New API defines the method, there's a framework conflict or you've got double inclusions in your code.");
// attach the .equals method to Array's prototype to call it on any array
Array.prototype.equals = function (array) {
// if the other array is a falsy value, return
if (!array)
return false;
// if the argument is the same array, we can be sure the contents are same as well
if(array === this)
return true;
// compare lengths - can save a lot of time
if (this.length != array.length)
return false;
for (var i = 0, l=this.length; i < l; i++) {
// Check if we have nested arrays
if (this[i] instanceof Array && array[i] instanceof Array) {
// recurse into the nested arrays
if (!this[i].equals(array[i]))
return false;
}
else if (this[i] != array[i]) {
// Warning - two different object instances will never be equal: {x:20} != {x:20}
return false;
}
}
return true;
}
// Hide method from for-in loops
Object.defineProperty(Array.prototype, "equals", {enumerable: false});
用法：
[1, 2, [3, 4]].equals([1, 2, [3, 2]]) === false;
[1, "2,3"].equals([1, 2, 3]) === false;
[1, 2, [3, 4]].equals([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].equals([1, 2, 1, 2]) === true;
你可能会说“但是比较字符串要快得多——没有循环……”那么你应该注意到有ARE循环。第一个递归循环将数组转换为字符串，第二个递归循环比较两个字符串。因此，此方法比使用字符串更快。
我认为，更大量的数据应该始终存储在数组中，而不是存储在对象中。但是，如果使用对象，也可以对它们进行部分比较。以下是操作方法：
比较对象：
我在上面说过，两个对象实例永远不会相等，即使它们当前包含相同的数据：
({a:1, foo:"bar", numberOfTheBeast: 666}) == ({a:1, foo:"bar", numberOfTheBeast: 666}) //false
这是有原因的，因为例如对象中可能存在私有变量。
但是，如果您只使用对象结构来包含数据，则仍然可以进行比较：
Object.prototype.equals = function(object2) {
//For the first loop, we only check for types
for (propName in this) {
//Check for inherited methods and properties - like .equals itself
//https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
//Return false if the return value is different
if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
return false;
}
//Check instance type
else if (typeof this[propName] != typeof object2[propName]) {
//Different types => not equal
return false;
}
}
//Now a deeper check using other objects property names
for(propName in object2) {
//We must check instances anyway, there may be a property that only exists in object2
//I wonder, if remembering the checked values from the first loop would be faster or not
if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
return false;
}
else if (typeof this[propName] != typeof object2[propName]) {
return false;
}
//If the property is inherited, do not check any more (it must be equa if both objects inherit it)
if(!this.hasOwnProperty(propName))
continue;
//Now the detail check and recursion
//This returns the script back to the array comparing
/**REQUIRES Array.equals**/
if (this[propName] instanceof Array && object2[propName] instanceof Array) {
// recurse into the nested arrays
if (!this[propName].equals(object2[propName]))
return false;
}
else if (this[propName] instanceof Object && object2[propName] instanceof Object) {
// recurse into another objects
//console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
if (!this[propName].equals(object2[propName]))
return false;
}
//Normal value comparison for strings and numbers
else if(this[propName] != object2[propName]) {
return false;
}
}
//If everything passed, let's say YES
return true;
}
然而，请记住，这一个用于比较类似JSON的数据，而不是类实例和其他东西。如果你想比较更复杂的对象，看看这个答案，它是一个超长函数。要使用Array.equals实现此功能，必须稍微编辑原始函数：
...
// Check if we have nested arrays
if (this[i] instanceof Array && array[i] instanceof Array) {
// recurse into the nested arrays
if (!this[i].equals(array[i]))
return false;
}
/**REQUIRES OBJECT COMPARE**/
else if (this[i] instanceof Object && array[i] instanceof Object) {
// recurse into another objects
//console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
if (!this[i].equals(array[i]))
return false;
}
else if (this[i] != array[i]) {
...
我为这两个功能制作了一个小测试工具。
附加：带有indexOf和包含的嵌套数组
Samy Bencherif为您在嵌套数组中搜索特定对象的情况准备了有用的函数，这些函数在这里提供：https://jsfiddle.net/SamyBencherif/8352y6yw/
我相信简单的JS和ECMAScript 2015，这很好理解。
var is_arrays_compare_similar = function (array1, array2) {
let flag = true;
if (array1.length == array2.length) {
// check first array1 object is available in array2 index
array1.every( array_obj => {
if (flag) {
if (!array2.includes(array_obj)) {
flag = false;
}
}
});
// then vice versa check array2 object is available in array1 index
array2.every( array_obj => {
if (flag) {
if (!array1.includes(array_obj)) {
flag = false;
}
}
});
return flag;
} else {
return false;
}
}
