如何检查两个数组是否与 JavaScript 相等？ [复制]

Question

这个问题在这里已经有了答案：

如何比较 JavaScript 中的数组？ (72 个回答)

5年前关闭。

var a = [1, 2, 3];
var b = [3, 2, 1];
var c = new Array(1, 2, 3);

alert(a == b + "|" + b == c);

演示

如何检查这些数组是否相等并获得一个方法，如果它们相等则返回true ？

jQuery 是否为此提供任何方法？

Answer 1

这是你应该做的。 请不要使用stringify或< > 。

function arraysEqual(a, b) {
  if (a === b) return true;
  if (a == null || b == null) return false;
  if (a.length !== b.length) return false;

  // If you don't care about the order of the elements inside
  // the array, you should sort both arrays here.
  // Please note that calling sort on an array will modify that array.
  // you might want to clone your array first.

  for (var i = 0; i < a.length; ++i) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}

Answer 2

[2021 更新日志：选项 4 的错误修正：js 对象没有总排序（甚至不包括NaN!=NaN和'5'==5 ( '5'===5 , '2'<3等)），所以不能在 Map.keys( .sort(cmpFunc)上使用.sort(cmpFunc) （尽管您可以在Object.keys(obj) ，因为即使是“数字”键也是字符串）。]

选项1

最简单的选项，几乎适用于所有情况，除了null !== undefined但它们都被转换为 JSON 表示null并被认为是相等的：

function arraysEqual(a1,a2) {
    /* WARNING: arrays must not contain {objects} or behavior may be undefined */
    return JSON.stringify(a1)==JSON.stringify(a2);
}

（如果您的数组包含对象，这可能不起作用。这是否仍然适用于对象取决于 JSON 实现是否对键进行排序。例如， {1:2,3:4}的 JSON 可能等于也可能不等于{3:4,1:2} ; 这取决于实现，规范不做任何保证。[2017 更新：实际上 ES6 规范现在保证对象键将按 1) 整数属性，2) 属性在它们被定义的顺序，然后 3) 符号属性按照它们被定义的顺序。 因此，如果 JSON.stringify 实现遵循这一点，则相等的对象（在 === 意义上但不一定在 == 意义上）将字符串化为相等的值。 需要更多的研究。 所以我猜你可以用相反的顺序对一个具有属性的对象进行邪恶的克隆，但我无法想象它会偶然发生......] 至少在 Chrome 上，JSON.stringify 函数倾向于按照它们的顺序返回键已定义（至少我已经注意到），但这种行为在任何时候都可能发生变化，不应依赖。 如果您选择不在列表中使用对象，这应该可以正常工作。 如果您的列表中确实有对象都具有唯一 id，则可以执行a1.map(function(x)}{return {id:x.uniqueId}}) 。 如果您的列表中有任意对象，您可以继续阅读选项 #2。）

这也适用于嵌套数组。

然而，由于创建这些字符串和对其进行垃圾收集的开销，它的效率略低。

---

选项 2

历史版本 1 解决方案：

 // generally useful functions function type(x) { // does not work in general, but works on JSONable objects we care about... modify as you see fit // eg type(/asdf/g) --> "[object RegExp]" return Object.prototype.toString.call(x); } function zip(arrays) { // eg zip([[1,2,3],[4,5,6]]) --> [[1,4],[2,5],[3,6]] return arrays[0].map(function(_,i){ return arrays.map(function(array){return array[i]}) }); } // helper functions function allCompareEqual(array) { // eg allCompareEqual([2,2,2,2]) --> true // does not work with nested arrays or objects return array.every(function(x){return x==array[0]}); } function isArray(x){ return type(x)==type([]) } function getLength(x){ return x.length } function allTrue(array){ return array.reduce(function(a,b){return a&&b},true) } // eg allTrue([true,true,true,true]) --> true // or just array.every(function(x){return x}); function allDeepEqual(things) { // works with nested arrays if( things.every(isArray) ) return allCompareEqual(things.map(getLength)) // all arrays of same length && allTrue(zip(things).map(allDeepEqual)); // elements recursively equal //else if( this.every(isObject) ) // return {all have exactly same keys, and for // each key k, allDeepEqual([o1[k],o2[k],...])} // eg ... && allTrue(objectZip(objects).map(allDeepEqual)) //else if( ... ) // extend some more else return allCompareEqual(things); } // Demo: allDeepEqual([ [], [], [] ]) true allDeepEqual([ [1], [1], [1] ]) true allDeepEqual([ [1,2], [1,2] ]) true allDeepEqual([ [[1,2],[3]], [[1,2],[3]] ]) true allDeepEqual([ [1,2,3], [1,2,3,4] ]) false allDeepEqual([ [[1,2],[3]], [[1,2],[],3] ]) false allDeepEqual([ [[1,2],[3]], [[1],[2,3]] ]) false allDeepEqual([ [[1,2],3], [1,[2,3]] ]) false

 <!-- More "proper" option, which you can override to deal with special cases (like regular objects and null/undefined and custom objects, if you so desire): To use this like a regular function, do: function allDeepEqual2() { return allDeepEqual([].slice.call(arguments)); } Demo: allDeepEqual2([[1,2],3], [[1,2],3]) true -->

---

选项 3

 function arraysEqual(a,b) { /* Array-aware equality checker: Returns whether arguments a and b are == to each other; however if they are equal-lengthed arrays, returns whether their elements are pairwise == to each other recursively under this definition. */ if (a instanceof Array && b instanceof Array) { if (a.length!=b.length) // assert same length return false; for(var i=0; i<a.length; i++) // assert each element equal if (!arraysEqual(a[i],b[i])) return false; return true; } else { return a==b; // if not both arrays, should be the same } } //Examples: arraysEqual([[1,2],3], [[1,2],3]) true arraysEqual([1,2,3], [1,2,3,4]) false arraysEqual([[1,2],[3]], [[1,2],[],3]) false arraysEqual([[1,2],[3]], [[1],[2,3]]) false arraysEqual([[1,2],3], undefined) false arraysEqual(undefined, undefined) true arraysEqual(1, 2) false arraysEqual(null, null) true arraysEqual(1, 1) true arraysEqual([], 1) false arraysEqual([], undefined) false arraysEqual([], []) true

 /* If you wanted to apply this to JSON-like data structures with js Objects, you could do so. Fortunately we're guaranteed that all objects keys are unique, so iterate over the objects OwnProperties and sort them by key, then assert that both the sorted key-array is equal and the value-array are equal, and just recurse. We CANNOT extend the sort-then-compare method with Maps as well; even though Map keys are unique, there is no total ordering in ecmascript, so you can't sort them... but you CAN query them individually (see the next section Option 4). (Also if we extend this to Sets, we run into the tree isomorphism problem http://logic.pdmi.ras.ru/~smal/files/smal_jass08_slides.pdf - fortunately it's not as hard as general graph isomorphism; there is in fact an O(#vertices) algorithm to solve it, but it can get very complicated to do it efficiently. The pathological case is if you have a set made up of lots of seemingly-indistinguishable objects, but upon further inspection some of those objects may differ as you delve deeper into them. You can also work around this by using hashing to reject almost all cases.) */

 <!-- **edit**: It's 2016 and my previous overcomplicated answer was bugging me. This recursive, imperative "recursive programming 101" implementation keeps the code really simple, and furthermore fails at the earliest possible point (giving us efficiency). It also doesn't generate superfluous ephemeral datastructures (not that there's anything wrong with functional programming in general, but just keeping it clean here). If we wanted to apply this to a non-empty arrays of arrays, we could do seriesOfArrays.reduce(arraysEqual). This is its own function, as opposed to using Object.defineProperties to attach to Array.prototype, since that would fail with a key error if we passed in an undefined value (that is however a fine design decision if you want to do so). This only answers OPs original question. -->

---

选项 4：（2016 年编辑的延续）

这应该适用于大多数对象：

 const STRICT_EQUALITY_BROKEN = (a,b)=> a===b; const STRICT_EQUALITY_NO_NAN = (a,b)=> { if (typeof a=='number' && typeof b=='number' && ''+a=='NaN' && ''+b=='NaN') // isNaN does not do what you think; see +/-Infinity return true; else return a===b; }; function deepEquals(a,b, areEqual=STRICT_EQUALITY_NO_NAN, setElementsAreEqual=STRICT_EQUALITY_NO_NAN) { /* compares objects hierarchically using the provided notion of equality (defaulting to ===); supports Arrays, Objects, Maps, ArrayBuffers */ if (a instanceof Array && b instanceof Array) return arraysEqual(a,b, areEqual); if (Object.getPrototypeOf(a)===Object.prototype && Object.getPrototypeOf(b)===Object.prototype) return objectsEqual(a,b, areEqual); if (a instanceof Map && b instanceof Map) return mapsEqual(a,b, areEqual); if (a instanceof Set && b instanceof Set) { if (setElementsAreEqual===STRICT_EQUALITY_NO_NAN) return setsEqual(a,b); else throw "Error: set equality by hashing not implemented because cannot guarantee custom notion of equality is transitive without programmer intervention." } if ((a instanceof ArrayBuffer || ArrayBuffer.isView(a)) && (b instanceof ArrayBuffer || ArrayBuffer.isView(b))) return typedArraysEqual(a,b); return areEqual(a,b); // see note[1] -- IMPORTANT } function arraysEqual(a,b, areEqual) { if (a.length!=b.length) return false; for(var i=0; i<a.length; i++) if (!deepEquals(a[i],b[i], areEqual)) return false; return true; } function objectsEqual(a,b, areEqual) { var aKeys = Object.getOwnPropertyNames(a); var bKeys = Object.getOwnPropertyNames(b); if (aKeys.length!=bKeys.length) return false; aKeys.sort(); bKeys.sort(); for(var i=0; i<aKeys.length; i++) if (!areEqual(aKeys[i],bKeys[i])) // keys must be strings return false; return deepEquals(aKeys.map(k=>a[k]), aKeys.map(k=>b[k]), areEqual); } function mapsEqual(a,b, areEqual) { // assumes Map's keys use the '===' notion of equality, which is also the assumption of .has and .get methods in the spec; however, Map's values use our notion of the areEqual parameter if (a.size!=b.size) return false; return [...a.keys()].every(k=> b.has(k) && deepEquals(a.get(k), b.get(k), areEqual) ); } function setsEqual(a,b) { // see discussion in below rest of StackOverflow answer return a.size==b.size && [...a.keys()].every(k=> b.has(k) ); } function typedArraysEqual(a,b) { // we use the obvious notion of equality for binary data a = new Uint8Array(a); b = new Uint8Array(b); if (a.length != b.length) return false; for(var i=0; i<a.length; i++) if (a[i]!=b[i]) return false; return true; }

 Demo (not extensively tested): var nineTen = new Float32Array(2); nineTen[0]=9; nineTen[1]=10; > deepEquals( [[1,[2,3]], 4, {a:5,'111':6}, new Map([['c',7],['d',8]]), nineTen], [[1,[2,3]], 4, {111:6,a:5}, new Map([['d',8],['c',7]]), nineTen] ) true > deepEquals( [[1,[2,3]], 4, {a:'5','111':6}, new Map([['c',7],['d',8]]), nineTen], [[1,[2,3]], 4, {111:6,a:5}, new Map([['d',8],['c',7]]), nineTen], (a,b)=>a==b ) true

请注意，如果使用==相等的概念，那么要知道 falsey 值和强制意味着==相等不是可传递的。 例如''==0和0=='0'但''!='0' 。 这与 Sets 相关：我认为人们无法以有意义的方式覆盖 Set 相等的概念。 如果使用 Set 相等的内置概念（即=== ），则上述方法应该有效。 然而，如果有人使用像==这样的非传递性相等概念，你就会打开一堆蠕虫：即使你强迫用户在域上定义一个哈希函数（hash(a)!=hash(b) 意味着 a! =b) 我不确定这会有所帮助...当然可以做 O(N^2) 性能事情并像冒泡排序一样逐个删除==项目对，然后再做第二个 O(N ^2) 传递以确认等价类中的东西实际上是==彼此，并且还!=到所有没有这样配对的东西，但如果你有一些强制，你仍然必须抛出运行时错误......你使用https://developer.mozilla.org/en-US/docs/Glossary/Falsy和 Truthy 值（除了 NaN==NaN ...但仅适用于 Sets！）。 对于大多数同类数据类型集，这通常不是问题。

总结集合上递归等式的复杂性：

• 集合相等是树同构问题http://logic.pdmi.ras.ru/~smal/files/smal_jass08_slides.pdf但稍微简单一点
• 设置 A =? 设置 B 与B.has(k) for every k in A同义， B.has(k) for every k in A隐式使用=== -equality ( [1,2,3]!==[1,2,3] )，而不是递归相等 ( deepEquals([1,2,3],[1,2,3]) == true )，所以两个new Set([[1,2,3]])不会相等，因为我们不递归
• 如果您使用的相等的递归概念不是 1) 自反性 (a=b 意味着 b=a) 和 2) 对称性 (a=a) 和 3) 传递性 (a=b b=c 意味着 a=c)； 这是等价类的定义
• 相等 == 运算符显然不遵守这些属性中的许多
• 甚至 ecmascript 中的严格相等=== 运算符也不遵守这些属性，因为ecmascript的严格相等比较算法有 NaN!=NaN; 这就是为什么许多本地数据类型（如Set和Map ）在它们作为键出现时“等同” NaN 以将它们视为相同的值
• 只要我们强制并确保递归集合相等确实是可传递的、自反的和对称的，我们就可以确保不会发生任何可怕的错误。
  • 然后，我们可以通过递归地随机比较所有内容来进行 O(N^2) 次比较，这是非常低效的。 没有神奇的算法可以让我们执行setKeys.sort((a,b)=> /*some comparison function*/)因为在 ecmascript (''==0 and 0=='0',但是 ''!='0'...虽然我相信您可以自己定义一个，这肯定是一个崇高的目标）。
  • 然而，我们可以.toString ify 或JSON.stringify所有元素来帮助我们。 然后我们将对它们进行排序，这为我们提供了潜在误报（两个不同的事物可能具有相同的字符串或 JSON 表示）的等价类（两个相同的事物不会具有相同的字符串 JSON 表示）。
    • 然而，这引入了它自己的性能问题，因为序列化相同的东西，然后一遍又一遍地序列化那个东西的子集，效率非常低。 想象一棵嵌套的Set树； 每个节点都属于 O(depth) 不同的序列化！
    • 即使这不是问题，如果所有序列化“提示”都相同，最坏情况的性能仍然是 O(N!)

因此，如果项目只是简单的 ===（不是递归的 ===），则上面的实现声明 Sets 是相等的。 这意味着它将为new Set([1,2,3])和new Set([1,2,3])返回 false 。 如果您知道自己在做什么，只需稍加努力，就可以重写该部分代码。

（旁注：地图是 es6 词典。我不知道它们是否具有 O(1) 或 O(log(N)) 查找性能，但无论如何它们都是“有序”的，因为它们会跟踪顺序其中插入了键值对。但是，如果元素以不同的顺序插入其中，则两个 Map 是否应该相等的语义是不明确的。我在下面给出了一个 deepEquals 的示例实现，它认为两个映射甚至相等如果元素以不同的顺序插入其中。）

（注意 [1]：重要：等式概念：您可能希望使用自定义的等式概念来覆盖注释行，您还必须在其他函数出现的任何位置更改该概念。例如，您是还是不？ '不是你想要 NaN==NaN 吗？默认情况下不是这样。还有更奇怪的东西，比如 0=='0'。你认为两个对象是相同的，当且仅当它们在内存？请参阅https://stackoverflow.com/a/5447170/711085 。您应该记录您使用的平等概念。）另请注意，天真地使用.toString和.sort其他答案有时可能会祈祷0!=-0但对于几乎所有数据类型和 JSON 序列化，都被视为相等且可规范化为 0； -0==0是否也应记录在您的平等概念中，以及该表中的大多数其他内容（如 NaN 等）中。

您应该能够将上述内容扩展到 WeakMaps、WeakSets。 不确定扩展到 DataViews 是否有意义。 也应该能够扩展到 RegExps 等。

当你扩展它时，你意识到你做了很多不必要的比较。 这是我之前定义的type函数（解决方案 #2）可以派上用场的地方； 然后你可以立即发货。 这是否值得（可能？不确定它在引擎盖下是如何工作的）表示类型的字符串的开销取决于您。 然后您可以将调度程序（即函数deepEquals重写为：

var dispatchTypeEquals = {
    number: function(a,b) {...a==b...},
    array: function(a,b) {...deepEquals(x,y)...},
    ...
}
function deepEquals(a,b) {
    var typeA = extractType(a);
    var typeB = extractType(a);
    return typeA==typeB && dispatchTypeEquals[typeA](a,b);
}

Answer 3

jQuery 没有比较数组的方法。 然而 Underscore库（或类似的 Lodash 库）确实有这样一个方法： isEqual ，它也可以处理各种其他情况（如对象文字）。 坚持提供的例子：

var a=[1,2,3];
var b=[3,2,1];
var c=new Array(1,2,3);

alert(_.isEqual(a, b) + "|" + _.isEqual(b, c));

顺便说一句：Underscore 有很多其他 jQuery 也没有的方法，所以它是对 jQuery 的一个很好的补充。

编辑：正如评论中指出的那样，上面的内容现在仅在两个数组的元素顺序相同时才有效，即：

_.isEqual([1,2,3], [1,2,3]); // true
_.isEqual([1,2,3], [3,2,1]); // false

幸运的是，Javascript 有一个内置的方法来解决这个确切的问题， sort ：

_.isEqual([1,2,3].sort(), [3,2,1].sort()); // true

Answer 4

对于像数字和字符串这样的原始值，这是一个简单的解决方案：

a = [1,2,3]

b = [3,2,1]

a.sort().toString() == b.sort().toString() 

对sort()的调用将确保元素的顺序无关紧要。 toString()调用将创建一个字符串，其中的值以逗号分隔，因此可以测试两个字符串的相等性。

Answer 5

使用 JavaScript 1.6 版就这么简单：

Array.prototype.equals = function( array ) {
  return this.length == array.length && 
         this.every( function(this_i,i) { return this_i == array[i] } )  
  }

例如， [].equals([])给出true ，而[1,2,3].equals( [1,3,2] ) false 。

Answer 6

即使这看起来非常简单，但有时它确实很有用。 如果您只需要查看两个数组是否具有相同的项并且它们的顺序是否相同，请尝试以下操作：

[1, 2, 3].toString() == [1, 2, 3].toString()
true
[1, 2, 3,].toString() == [1, 2, 3].toString()
true
[1,2,3].toString() == [1, 2, 3].toString()
true

但是，这不适用于模式高级情况，例如：

[[1,2],[3]].toString() == [[1],[2,3]].toString()
true

这取决于你需要什么。

Answer 7

根据 Tim James 的回答和 Fox32 的评论，以下内容应检查空值，并假设两个空值不相等。

function arrays_equal(a,b) { return !!a && !!b && !(a<b || b<a); }

> arrays_equal([1,2,3], [1,3,4])
false
> arrays_equal([1,2,3], [1,2,3])
true
> arrays_equal([1,3,4], [1,2,3])
false
> arrays_equal(null, [1,2,3])
false
> arrays_equal(null, null)
false

Answer 8

检查数组的大小后，通过 for 循环检查每个值。

function equalArray(a, b) {
    if (a.length === b.length) {
        for (var i = 0; i < a.length; i++) {
            if (a[i] !== b[i]) {
                return false;
            }
        }
        return true;
    } else {
        return false;
    }
}

Answer 9

jQuery 有这种深度递归比较的方法。

本土通用的严格平等检查可能如下所示：

function deepEquals(obj1, obj2, parents1, parents2) {
    "use strict";
    var i;
    // compare null and undefined
    if (obj1 === undefined || obj2 === undefined || 
        obj1 === null || obj2 === null) {
        return obj1 === obj2;
    }

    // compare primitives
    if (typeof (obj1) !== 'object' || typeof (obj2) !== 'object') {
        return obj1.valueOf() === obj2.valueOf();
    }

    // if objects are of different types or lengths they can't be equal
    if (obj1.constructor !== obj2.constructor || (obj1.length !== undefined && obj1.length !== obj2.length)) {
        return false;
    }

    // iterate the objects
    for (i in obj1) {
        // build the parents list for object on the left (obj1)
        if (parents1 === undefined) parents1 = [];
        if (obj1.constructor === Object) parents1.push(obj1);
        // build the parents list for object on the right (obj2)
        if (parents2 === undefined) parents2 = [];
        if (obj2.constructor === Object) parents2.push(obj2);
        // walk through object properties
        if (obj1.propertyIsEnumerable(i)) {
            if (obj2.propertyIsEnumerable(i)) {
                // if object at i was met while going down here
                // it's a self reference
                if ((obj1[i].constructor === Object && parents1.indexOf(obj1[i]) >= 0) || (obj2[i].constructor === Object && parents2.indexOf(obj2[i]) >= 0)) {
                    if (obj1[i] !== obj2[i]) {
                        return false;
                    }
                    continue;
                }
                // it's not a self reference so we are here
                if (!deepEquals(obj1[i], obj2[i], parents1, parents2)) {
                    return false;
                }
            } else {
                // obj2[i] does not exist
                return false;
            }
        }
    }
    return true;
};

测试：

// message is displayed on failure
// clean console === all tests passed
function assertTrue(cond, msg) {
    if (!cond) {
        console.log(msg);
    }
}

var a = 'sdf',
    b = 'sdf';
assertTrue(deepEquals(b, a), 'Strings are equal.');
b = 'dfs';
assertTrue(!deepEquals(b, a), 'Strings are not equal.');
a = 9;
b = 9;
assertTrue(deepEquals(b, a), 'Numbers are equal.');
b = 3;
assertTrue(!deepEquals(b, a), 'Numbers are not equal.');
a = false;
b = false;
assertTrue(deepEquals(b, a), 'Booleans are equal.');
b = true;
assertTrue(!deepEquals(b, a), 'Booleans are not equal.');
a = null;
assertTrue(!deepEquals(b, a), 'Boolean is not equal to null.');
a = function () {
    return true;
};
assertTrue(deepEquals(
[
    [1, 1, 1],
    [2, 'asdf', [1, a]],
    [3, {
        'a': 1.0
    },
    true]
], 
[
    [1, 1, 1],
    [2, 'asdf', [1, a]],
    [3, {
        'a': 1.0
    },
    true]
]), 'Arrays are equal.');
assertTrue(!deepEquals(
[
    [1, 1, 1],
    [2, 'asdf', [1, a]],
    [3, {
        'a': 1.0
    },
    true]
],
[
    [1, 1, 1],
    [2, 'asdf', [1, a]],
    [3, {
        'a': '1'
    },
    true]
]), 'Arrays are not equal.');
a = {
    prop: 'val'
};
a.self = a;
b = {
    prop: 'val'
};
b.self = a;
assertTrue(deepEquals(b, a), 'Immediate self referencing objects are equal.');
a.prop = 'shmal';
assertTrue(!deepEquals(b, a), 'Immediate self referencing objects are not equal.');
a = {
    prop: 'val',
    inside: {}
};
a.inside.self = a;
b = {
    prop: 'val',
    inside: {}
};
b.inside.self = a;
assertTrue(deepEquals(b, a), 'Deep self referencing objects are equal.');
b.inside.self = b;
assertTrue(!deepEquals(b, a), 'Deep self referencing objects are not equeal. Not the same instance.');
b.inside.self = {foo: 'bar'};
assertTrue(!deepEquals(b, a), 'Deep self referencing objects are not equal. Completely different object.');
a = {};
b = {};
a.self = a;
b.self = {};
assertTrue(!deepEquals(b, a), 'Empty object and self reference of an empty object.');

Answer 10

如果您正在使用 lodash 并且不想修改任何一个数组，您可以使用函数 _.xor() 。 它将两个数组作为集合进行比较，并返回包含它们差异的集合。 如果该差值的长度为零，则两个数组本质上相等：

var a = [1, 2, 3];
var b = [3, 2, 1];
var c = new Array(1, 2, 3);
_.xor(a, b).length === 0
true
_.xor(b, c).length === 0
true

Answer 11

使用map()和reduce() ：

function arraysEqual (a1, a2) {
    return a1 === a2 || (
        a1 !== null && a2 !== null &&
        a1.length === a2.length &&
        a1
            .map(function (val, idx) { return val === a2[idx]; })
            .reduce(function (prev, cur) { return prev && cur; }, true)
    );
}

Answer 12

如果您希望检查对象数组的相等性和顺序无关紧要，即

areEqual([{id: "0"}, {id: "1"}], [{id: "1"}, {id: "0"}]) // true

您首先要对数组进行排序。 通过组合sortBy和isEqual ， lodash拥有您需要的所有工具：

// arr1 & arr2: Arrays of objects 
// sortProperty: the property of the object with which you want to sort
// Note: ensure every object in both arrays has your chosen sortProperty
// For example, arr1 = [{id: "v-test_id0"}, {id: "v-test_id1"}]
// and          arr2 = [{id: "v-test_id1"}, {id: "v-test_id0"}]
// sortProperty should be 'id'

function areEqual (arr1, arr2, sortProperty) {
  return _.areEqual(_.sortBy(arr1, sortProperty), _.sortBy(arr2, sortProperty))
}

编辑：由于sortBy返回一个新数组，因此无需在排序前克隆数组。 原始数组不会发生变异。

请注意，对于 lodash 的isEqual ，顺序确实很重要。 如果sortBy未首先应用于每个数组，则上面的示例将返回false 。

Answer 13

这个方法很烂，但我把它留在这里供参考，所以其他人避免走这条路：

---

使用来自@ninjagecko 的选项 1 对我来说效果最好：

Array.prototype.equals = function(array) {
    return array instanceof Array && JSON.stringify(this) === JSON.stringify(array) ;
}

a = [1, [2, 3]]
a.equals([[1, 2], 3]) // false
a.equals([1, [2, 3]]) // true

它还将处理 null 和 undefined 情况，因为我们将它添加到数组的原型中并检查另一个参数是否也是一个数组。

Answer 14

没有简单的方法可以做到这一点。 我也需要这个，但想要一个可以接受任意两个变量并测试相等性的函数。 这包括非对象值、对象、数组和任何级别的嵌套。

在您的问题中，您提到要忽略数组中值的顺序。 我的解决方案本身并不是这样做的，但是您可以通过在比较相等性之前对数组进行排序来实现它

我还想要将非对象转换为字符串的选项，以便 [1,2]===["1",2]

由于我的项目使用 UnderscoreJs，我决定使它成为一个 mixin 而不是一个独立的函数。

您可以在http://jsfiddle.net/nemesarial/T44W4/上对其进行测试

这是我的 mxin：

_.mixin({
  /**
  Tests for the equality of two variables
    valA: first variable
    valB: second variable
    stringifyStatics: cast non-objects to string so that "1"===1
  **/
  equal:function(valA,valB,stringifyStatics){
    stringifyStatics=!!stringifyStatics;

    //check for same type
    if(typeof(valA)!==typeof(valB)){
      if((_.isObject(valA) || _.isObject(valB))){
        return false;
      }
    }

    //test non-objects for equality
    if(!_.isObject(valA)){
      if(stringifyStatics){
        var valAs=''+valA;
        var valBs=''+valB;
        ret=(''+valA)===(''+valB);
      }else{
        ret=valA===valB;
      }
      return ret;
    }

    //test for length
    if(_.size(valA)!=_.size(valB)){
      return false;
    }

    //test for arrays first
    var isArr=_.isArray(valA);

    //test whether both are array or both object
    if(isArr!==_.isArray(valB)){
      return false;
    }

    var ret=true;
    if(isArr){
      //do test for arrays
      _.each(valA,function(val,idx,lst){
        if(!ret){return;}
        ret=ret && _.equal(val,valB[idx],stringifyStatics);
      });
    }else{
      //do test for objects
      _.each(valA,function(val,idx,lst){
        if(!ret){return;}

        //test for object member exists
        if(!_.has(valB,idx)){
          ret=false;
          return;
        }

        // test for member equality
        ret=ret && _.equal(val,valB[idx],stringifyStatics);
      });

    }
    return ret;
  }
});

这是你如何使用它：

_.equal([1,2,3],[1,2,"3"],true)

要演示嵌套，您可以执行以下操作：

_.equal(
    ['a',{b:'b',c:[{'someId':1},2]},[1,2,3]],
    ['a',{b:'b',c:[{'someId':"1"},2]},["1",'2',3]]
,true);

Answer 15

它处理所有可能的东西，甚至在对象结构中引用自身。 您可以在代码末尾看到示例。

var deepCompare = (function() {
    function internalDeepCompare (obj1, obj2, objects) {
        var i, objPair;

        if (obj1 === obj2) {
            return true;
        }

        i = objects.length;
        while (i--) {
            objPair = objects[i];
            if (  (objPair.obj1 === obj1 && objPair.obj2 === obj2) ||
                  (objPair.obj1 === obj2 && objPair.obj2 === obj1)  ) {                          
                return true;
            }                    
        }
        objects.push({obj1: obj1, obj2: obj2});

        if (obj1 instanceof Array) {
            if (!(obj2 instanceof Array)) {
                return false;
            }

            i = obj1.length;

            if (i !== obj2.length) {
               return false; 
            }

            while (i--) {
                if (!internalDeepCompare(obj1[i], obj2[i], objects)) {
                    return false;
                }
            }
        }
        else {
            switch (typeof obj1) {
                case "object":                
                    // deal with null
                    if (!(obj2 && obj1.constructor === obj2.constructor)) {
                        return false;
                    }

                    if (obj1 instanceof RegExp) {
                        if (!(obj2 instanceof RegExp && obj1.source === obj2.source)) {
                            return false;
                        }
                    }                 
                    else if (obj1 instanceof Date) {
                        if (!(obj2 instanceof Date && obj1.getTime() === obj2.getTime())) {
                            return false;
                        }
                    } 
                    else {    
                        for (i in obj1) {
                            if (obj1.hasOwnProperty(i)) {       
                                if (!(obj2.hasOwnProperty(i) && internalDeepCompare(obj1[i], obj2[i], objects))) {
                                    return false;
                                }
                            }
                        }         
                    }
                    break;
                case "function": 
                    if (!(typeof obj2 === "function" && obj1+"" === obj2+"")) {
                        return false;
                    }
                    break;
                default:                 //deal with NaN 
                    if (obj1 !== obj2 && obj1 === obj1 && obj2 === obj2) {
                        return false;            
                    }
            }
        }

        return true;
    }

    return function (obj1, obj2) {
        return internalDeepCompare(obj1, obj2, []);    
    };
}());

/*    
var a = [a, undefined, new Date(10), /.+/, {a:2}, function(){}, Infinity, -Infinity, NaN, 0, -0, 1, [4,5], "1", "-1", "a", null],
    b = [b, undefined, new Date(10), /.+/, {a:2}, function(){}, Infinity, -Infinity, NaN, 0, -0, 1, [4,5], "1", "-1", "a", null];
deepCompare(a, b);
*/

Answer 16

var a= [1, 2, 3, '3'];
var b = [1, 2, 3];

var c = a.filter(function (i) { return ! ~b.indexOf(i); });

alert(c.length);