我想比较两个数组……最好是高效地进行。不需要花哨的操作，只需在它们相同时返回true，否则返回false。不出所料，比较运算符似乎无法胜任。
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对每个数组进行编码，但是否有更快或“更好”的方法，可以在不必迭代每个值的情况下简单地比较数组？
要比较数组，需要循环遍历它们并逐个比较每个值：
// 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;
你可能会说：“但是比较字符串会快得多 - 没有循环...”，那么你应该注意，确实存在循环。首先是递归循环将数组转换为字符串，其次是比较两个字符串的循环。因此，这种方法比使用字符串更快。
我认为大量的数据应该始终存储在数组中，而不是对象中。然而，如果你使用对象，它们也可以进行部分比较。
下面是具体方法：
如上所述，即使它们在某一时刻包含相同的数据，两个对象实例也永远不会相等：
({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和contains处理嵌套数组Samy Bencherif准备了有用的函数，用于在嵌套数组中搜索特定对象，可以在这里找到: https://jsfiddle.net/SamyBencherif/8352y6yw/
this[i] !== array[i]而不是!=。 - Tim S.equals 而不是 compare。至少在 .NET 中，compare 通常会返回一个有符号整数，表示哪个对象大于另一个对象。请参见：Comparer.Compare。 - Oliver虽然这仅适用于标量数组（见下面的注释），但代码很短：
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])
(注意: 这里的“标量”指可直接使用 === 进行比较的值。因此：数字、字符串、按引用传递的对象、按引用传递的函数。有关比较运算符的更多信息，请参见MDN参考文档。)
更新
从评论中得出，对数组进行排序并进行比较可能会得到准确的结果：
const array2Sorted = array2.slice().sort();
array1.length === array2.length && array1.slice().sort().every(function(value, index) {
return value === array2Sorted[index];
});
array1 = [2,3,1,4];
array2 = [1,2,3,4];
那么上面的代码将返回true
a1.length==a2.length && a1.every((v,i)=>a2.includes(v))：var a1 =[1,2,3], a2 = [3,2,1];（var a1 =[1,3,3], a2 = [1,1,3];将不能如预期般工作）。 - mems我喜欢在需要处理数组或对象的重度编码项目中使用Underscore库… 在Underscore和Lodash中，无论是比较数组还是对象，它看起来都像这样：
_.isEqual(array1, array2) // returns a boolean
_.isEqual(object1, object2) // returns a boolean
_.isEqual([1,2,3], [2,1,3]) => false。 - Vitalii AlekaskisEqual功能，可以始终使用lodash.isequal模块。 - hellatan_.isEqual([1,2,3].sort(), [2,1,3].sort()) => true - filype我认为使用JSON stringify这是最简单的方法，并且在某些情况下可能是最好的解决方案：
JSON.stringify(a1) === JSON.stringify(a2);
这将对象a1和a2转换为字符串，以便它们可以进行比较。在大多数情况下，顺序很重要，因为可以使用上面其中一个答案中显示的排序算法来对对象进行排序。
请注意，您现在比较的是对象的字符串表示形式，可能不完全符合您的要求。
JSON.stringify() - 对于简单的用例来说，它感觉是最容易的选择... - Mars Robertson以原问题的精神为基础：
我想比较两个数组... 最好是 高效地。 没有花哨的，如果它们相同则返回 true，否则返回 false。
我已经对这里提出的一些更简单的建议进行了性能测试，以下是结果（从快到慢）：
while (67%) by Tim Down
var i = a1.length;
while (i--) {
if (a1[i] !== a2[i]) return false;
}
return true
每个（69%）由user2782196发布
a1.every((v,i)=> v === a2[i]);
reduce（74%）由DEIs完成
a1.reduce((a, b) => a && a2.includes(b), true);
join & toString (78%) 由 Gaizka Allende 和 vivek 创作
a1.join('') === a2.join('');
a1.toString() === a2.toString();
half toString (90%) 由 Victor Palomo 完成
a1 == a2.toString();
stringify (100%) 由radtek创建
JSON.stringify(a1) === JSON.stringify(a2);
.length比较（将a1.length === a2.length添加到任何建议中，您将获得约10%的性能提升）。选择最适合您的解决方案，了解每个解决方案的速度和限制即可。arrEvery()和一个减速版本。
function arrEvery(a1,a2)
{
// user2782196: https://dev59.com/V2sz5IYBdhLWcg3wiISe#19746771
return a1.every((v,i)=> v === a2[i]);
}
// slowed down
function arrEveryWithSlowDown(a1,a2)
{
setTimeout(() => {
console.log("Slow down pal!");
}, 1500);
return a1.every((v,i)=> v === a2[i]);
}
arrEvery 的缓慢版本具有较低的百分比。括号中的数字可能是运行的周期数/操作数。
Array.from({length: 1000}).map((a,v)=> ${v}.padStart(10,2));。 - Narayona1和a2连接之前使用sort()。例如，a1.sort().join("")===a2.sort().join("")。 - KR Tirthojoin('')很危险，因为['foo'，'bar'].join（''）== ['foobar'] .join（''）。我更喜欢a1 ==''+ a2。 - Cees Timmermanwhile所需的时间将是使用stringify所需时间的67％。这与面包师百分比有些相似... - Shawn我认为说某个特定的实现方式是“正确的”（“correct”）只是因为它与“错误”的解决方案相比而言是“正确的”，这种说法是不正确的。 Tomáš的解决方案明显比基于字符串比较数组要好，但这并不意味着它从客观上来说就是“正确的”。到底什么才是“正确”的呢？是最快的吗？最灵活的吗？易于理解吗？最快速调试的吗？使用的操作最少吗？它会有任何副作用吗？没有一种解决方案可以拥有所有优点。
Tomáš可能会说他的解决方案很快，但我也会说它过于复杂了。它试图成为一个适用于所有数组，包括嵌套数组在内的多合一解决方案。实际上，它甚至接受更多不同于数组的输入，并仍然尝试给出一个“有效”的答案。
我的答案将以一种不同的方式来解决这个问题。我将从一个通用的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)
arrayCompare函数接受比较函数f和两个输入数组xs和ys。在大部分情况下，我们只是对输入数组中的每个元素调用f(x)(y)。如果用户定义的f返回false，我们会提前返回false——这要感谢&&的短路评估。所以是的，这意味着比较器可以在不必要时停止迭代并防止循环遍历其余的输入数组。
arrayCompare函数，我们可以轻松创建其他可能需要的函数。我们将从基本的arrayEqual开始...// 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
如此简单。可以使用arrayCompare和一个比较函数定义arrayEqual，该函数使用===（用于严格相等性）将a与b进行比较。
请注意，我们还将equal定义为自己的函数。这突出了arrayCompare作为高阶函数在另一个数据类型（数组）的上下文中利用我们的一阶比较器的角色。
我们也可以使用==来定义arrayLooseEqual，这样当比较1（数字）和'1'（字符串）时，结果将是true……
// 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 是柯里化的，因此我们也可以像之前的示例一样部分应用它。
// 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比较器！我知道孩子们喜欢那些正则表达式…
它是最快的吗？不是。但它可能也不需要。如果速度是衡量我们代码质量的唯一指标，很多真正优秀的代码都会被丢弃 - 这就是为什么我称这种方法为“实用方式”的原因。或者更公平地说，是“一种”实用方式。这个描述适用于此答案，因为我并不是说这个答案只有在与其他答案相比时才是实用的；这是客观的事实。我们用很少的代码达到了高度的实用性，而这些代码很容易理解。没有其他代码可以说我们没有赢得这个称号。
这是否使它成为“正确”的解决方案？这取决于你。没有人能为你做这个决定；只有你知道你的需求。在几乎所有情况下，我更看重直接、实用和多功能的代码而不是聪明和快速的代码。你重视什么可能不同，所以选择适合你的。
我的旧答案更侧重于将arrayEqual分解为小程序。这是一个有趣的练习，但并不是处理这个问题的最佳（最实用）方式。如果您感兴趣，可以查看此修订历史记录。
arrayCompare 吗？是的，该函数是柯里化的，但它与 some 和 every 不同。arrayCompare 需要一个比较器和两个数组进行比较。我选择了一个特别通用的名称，因为我们可以使用任意函数来比较数组。该函数是柯里化的，因此可以专门用于创建新的数组比较函数（例如，arrayEqual）。您能否建议更好的名称？您认为哪些方面需要额外的注释或解释？我很乐意讨论 ^_^ - Mulan你所说的“相同”意思不明确。例如，下面的数组a和b是否相同（注意嵌套数组）？
var a = ["foo", ["bar"]], b = ["foo", ["bar"]];
这是一个优化的数组比较函数，它逐个比较每个数组对应的元素，使用严格相等运算符，并不会对自身为数组的数组元素进行递归比较。对于上述示例，arraysIdentical(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;
};
true，那么它只会失败。这个答案解释了它不会返回 true。如果你需要比较嵌套的数组，你可以轻松地添加递归检查。 - Tim Down在Tomáš Zato的回答基础上，我同意仅仅迭代遍历数组是最快的方法。此外（就像其他人已经说过的那样），这个函数应该被称为equals/equal，而不是compare。考虑到这一点，我修改了这个函数，以处理比较相似数组 - 即它们具有相同的元素，但顺序不同 - 供个人使用，并想让大家都看到。
Array.prototype.equals = function (array, strict) {
if (!array)
return false;
if (arguments.length == 1)
strict = true;
if (this.length != array.length)
return false;
for (var i = 0; i < this.length; i++) {
if (this[i] instanceof Array && array[i] instanceof Array) {
if (!this[i].equals(array[i], strict))
return false;
}
else if (strict && this[i] != array[i]) {
return false;
}
else if (!strict) {
return this.sort().equals(array.sort(), true);
}
}
return true;
}
此函数需要一个额外的参数strict，默认为true。严格模式(strict mode)定义了数组内容以及顺序是否完全相等，或者仅包含相同的内容。
例子：
var arr1 = [1, 2, 3, 4];
var arr2 = [2, 1, 4, 3]; // Loosely equal to 1
var arr3 = [2, 2, 3, 4]; // Not equal to 1
var arr4 = [1, 2, 3, 4]; // Strictly equal to 1
arr1.equals(arr2); // false
arr1.equals(arr2, false); // true
arr1.equals(arr3); // false
arr1.equals(arr3, false); // false
arr1.equals(arr4); // true
arr1.equals(arr4, false); // true
我也用这个函数编写了一个快速的jsfiddle示例：
http://jsfiddle.net/Roundaround/DLkxX/
与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
.join()而不是JSON。如果你把第二种解决方案作为主要方案（尽管它对多维数组无效，但更好），我就不会这样评价你了。到目前为止，我已经给所有将数组转换为字符串的答案点了踩。同时，我也点赞了那些使用正确方法的答案，以防你需要知道。这意味着@Tim Down的答案和Bireys的答案。 - Tomáš ZatocheckArrays([1,2,3] , ["1,2",3]) == true，这很不可能是你想要发生的！ - Doinjoin()会使其微妙地出错！ - Doinconst newArray = [ ...new Set( [...arr1, ...arr2] ) ]
问题中没有说明数组的结构将是什么样子的，所以如果您确定您的数组中不会有嵌套数组和对象（我遇到过这种情况，这就是我写这篇答案的原因），那么上面的代码将起作用。
发生的事情是我们使用展开操作符（...）将两个数组连接起来，然后使用Set来消除任何重复项。一旦你有了这个，你可以比较它们的大小，如果三个数组的大小相同，你就可以继续了。
这个答案也忽略了元素的顺序，正如我所说，恰巧发生在我身上，所以也许处于同样境地的人也会来到这里（就像我一样）。
Edit1.
回答Dmitry Grinko的问题：“为什么你在这里使用展开操作符（...）- ...new Set？它不能工作”
考虑以下代码：
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' ]
这就是区别所在：前者会给我一个集合（Set），它也可以工作，因为我可以得到该集合的大小，但后者却直接给我所需的数组，更加直接解决问题。
([] == []) == false这样的愚蠢行为是不可原谅的。 - Alex D