blocks|key|1214110|text|这就是你应该做的。请不要使用stringify或<+>。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1214111|function+arraysEqual(a,+b)+{
++if+(a+===+b)+return+true;
++if+(a+==+null+%7C%7C+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;+%2B%2Bi)+{
++++if+(a[i]+!==+b[i])+return+false;
++}
++return+true;
}|code-block|syntax|javascript|1214112|entityMap^0|E|9|O|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

This is what you should do. Please do not use <code>stringify</code> nor <code>&lt; &gt;</code>.

<pre><code>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 &lt; a.length; ++i) {
 if (a[i] !== b[i]) return false;
 }
 return true;
}
</code></pre>

blocks|key|999827|text|对于像数字和字符串这样的原始值，这是一个简单的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|999828|a+=+[1,2,3]

b+=+[3,2,1]

a.sort().toString()+==+b.sort().toString()+|code-block|syntax|javascript|999829|对sort()的调用将确保元素的顺序不重要。toString()调用将创建一个以逗号分隔的字符串，以便可以测试两个字符串是否相等。|offset|length|style|CODE|999830|entityMap^0|0|0|1|6|M|A|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

For primitive values like numbers and strings this is an easy solution:

<pre><code>a = [1,2,3]

b = [3,2,1]

a.sort().toString() == b.sort().toString() 
</code></pre>

The call to <code>sort()</code> will ensure that the order of the elements does not matter. The <code>toString()</code> call will create a string with the values comma separated so both strings can be tested for equality.

blocks|key|1214170|text|在JavaScript版本1.6中，它就像这样简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1214171|Array.prototype.equals+=+function(+array+)+{
++return+this.length+==+array.length+&&+
+++++++++this.every(+function(this_i,i)+{+return+this_i+==+array[i]+}+)++
++}|code-block|syntax|javascript|1214172|例如，[].equals([])产生true，而[1,2,3].equals(+[1,3,2]+)产生false。|offset|length|style|CODE|1214173|entityMap^0|0|0|3|D|I|4|O|P|1F|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

With JavaScript version 1.6 it's as easy as this:

<pre><code>Array.prototype.equals = function( array ) {
 return this.length == array.length &amp;&amp; 
 this.every( function(this_i,i) { return this_i == array[i] } ) 
 }
</code></pre>

For example, <code>[].equals([])</code> gives <code>true</code>, while <code>[1,2,3].equals( [1,3,2] )</code> yields <code>false</code>.

blocks|key|1214013|text|即使这看起来非常简单，有时也是非常有用的。如果您所需要的只是查看两个数组是否具有相同的项，并且它们的顺序相同，请尝试以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1214014|[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|code-block|syntax|javascript|1214015|但是，这不适用于模式高级情况，例如：|1214016|[[1,2],[3]].toString()+==+[[1],[2,3]].toString()
true|1214017|这取决于你需要什么。|1214018|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Even if this would seem super simple, sometimes it's really useful. If all you need is to see if two arrays have the same items and they are in the same order, try this:

<pre><code>[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
</code></pre>

However, this doesn't work for mode advanced cases such as:

<pre><code>[[1,2],[3]].toString() == [[1],[2,3]].toString()
true
</code></pre>

It depends what you need.

blocks|key|999711|text|基于Tim+James+answer和Fox32的评论，下面的代码应该检查空值，并假设两个空值不相等。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|999712|function+arrays_equal(a,b)+{+return+!!a+&&+!!b+&&+!(a<b+%7C%7C+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|code-block|syntax|javascript|999713|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5115066/28810^0|C|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Based on Tim James <a href="https://stackoverflow.com/a/5115066/28810">answer</a> and Fox32's comment, the following should check for nulls, with the assumption that two nulls are not equal.

<pre><code>function arrays_equal(a,b) { return !!a &amp;&amp; !!b &amp;&amp; !(a&lt;b || b&lt;a); }

&gt; arrays_equal([1,2,3], [1,3,4])
false
&gt; arrays_equal([1,2,3], [1,2,3])
true
&gt; arrays_equal([1,3,4], [1,2,3])
false
&gt; arrays_equal(null, [1,2,3])
false
&gt; arrays_equal(null, null)
false
</code></pre>

blocks|key|1000191|text|一旦检查了数组的大小，就会通过for循环检查每个值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000192|function+equalArray(a,+b)+{
++++if+(a.length+===+b.length)+{
++++++++for+(var+i+=+0;+i+<+a.length;+i%2B%2B)+{
++++++++++++if+(a[i]+!==+b[i])+{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++++++return+true;
++++}+else+{
++++++++return+false;
++++}
}|code-block|syntax|javascript|1000193|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Check every each value by a for loop once you checked the size of the array.

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

blocks|key|1000143|text|如果您正在使用lodash，并且不想修改这两个数组中的任何一个，则可以使用the+function+_.xor()。它将两个数组作为集合进行比较，并返回包含它们差异的集合。如果该差异的长度为零，则两个数组本质上相等：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1000144|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|code-block|syntax|javascript|1000145|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs/#xor^0|11|K|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If you are using lodash and don't want to modify either array, you can use <a href="https://lodash.com/docs/#xor" rel="nofollow">the function _.xor()</a>. It compares the two arrays as sets and returns the set that contains their difference. If the length of this difference is zero, the two arrays are essentially equal:

<pre><code>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
</code></pre>

blocks|key|1214355|text|使用map()和reduce()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1214356|function+arraysEqual+(a1,+a2)+{
++++return+a1+===+a2+%7C%7C+(
++++++++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)
++++);
}|code-block|syntax|javascript|1214357|entityMap^0|2|5|8|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Using <code>map()</code> and <code>reduce()</code>:

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

blocks|key|1214271|text|没有简单的方法可以做到这一点。我也需要这个，但是我想要一个可以接受任意两个变量并测试相等性的函数。包括非对象值、对象、数组和任何级别的嵌套。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1214272|在您的问题中，您提到要忽略数组中值的顺序。我的解决方案本身并没有做到这一点，但是您可以通过在比较相等之前对数组进行排序来实现这一点|1214273|我还想选择将非对象转换为字符串，这样1,2==="1",2|1214274|因为我的项目使用UnderscoreJs，所以我决定让它成为一个混合函数，而不是一个独立的函数。|1214275|您可以在http://jsfiddle.net/nemesarial/T44W4/上测试它|offset|length|1214276|这是我的mxin：|1214277|_.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)+%7C%7C+_.isObject(valB))){
++++++++return+false;
++++++}
++++}

++++//test+non-objects+for+equality
++++if(!_.isObject(valA)){
++++++if(stringifyStatics){
++++++++var+valAs=''%2BvalA;
++++++++var+valBs=''%2BvalB;
++++++++ret=(''%2BvalA)===(''%2BvalB);
++++++}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;
++}
});|code-block|syntax|javascript|1214278|下面是它的使用方法：|1214279|_.equal([1,2,3],[1,2,"3"],true)|1214280|要演示嵌套，可以执行以下操作：|1214281|_.equal(
++++['a',{b:'b',c:[{'someId':1},2]},[1,2,3]],
++++['a',{b:'b',c:[{'someId':"1"},2]},["1",'2',3]]
,true);|1214282|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/nemesarial/T44W4/^0|0|0|0|0|4|11|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1B|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1C|8|@]|9|@$J|1D|K|1E|1|1F]]|A|$]]|$1|L|3|M|5|6|7|1G|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1H|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|P|7|1J|8|@]|9|@]|A|$Q|R]]|$1|W|3|X|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|1L|8|@]|9|@]|A|$Q|R]]|$1|10|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]]]

There is no easy way to do this. I needed this as well, but wanted a function that can take any two variables and test for equality. That includes non-object values, objects, arrays and any level of nesting. 

In your question, you mention wanting to ignore the order of the values in an array. My solution doesn't inherently do that, but you can achieve it by sorting the arrays before comparing for equality

I also wanted the option of casting non-objects to strings so that [1,2]===["1",2]

Since my project uses UnderscoreJs, I decided to make it a mixin rather than a standalone function. 

You can test it out on <a href="http://jsfiddle.net/nemesarial/T44W4/" rel="nofollow">http://jsfiddle.net/nemesarial/T44W4/</a>

Here is my mxin:

<pre><code>_.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 &amp;&amp; _.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 &amp;&amp; _.equal(val,valB[idx],stringifyStatics);
 });

 }
 return ret;
 }
});
</code></pre>

This is how you use it:

<pre><code>_.equal([1,2,3],[1,2,"3"],true)
</code></pre>

To demonstrate nesting, you can do this:

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

blocks|key|1214309|text|它处理所有可能内容，甚至在对象结构中引用自身。您可以在代码末尾看到示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1214310|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)+%7C%7C
++++++++++++++++++(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%2B""+===+obj2%2B""))+{
++++++++++++++++++++++++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),+/.%2B/,+{a:2},+function(){},+Infinity,+-Infinity,+NaN,+0,+-0,+1,+[4,5],+"1",+"-1",+"a",+null],
++++b+=+[b,+undefined,+new+Date(10),+/.%2B/,+{a:2},+function(){},+Infinity,+-Infinity,+NaN,+0,+-0,+1,+[4,5],+"1",+"-1",+"a",+null];
deepCompare(a,+b);
*/|code-block|syntax|javascript|1214311|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It handle all possible stuff and even reference itself in structure of object. You can see the example at the end of code.

<pre><code>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 &amp;&amp; objPair.obj2 === obj2) ||
 (objPair.obj1 === obj2 &amp;&amp; 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 &amp;&amp; obj1.constructor === obj2.constructor)) {
 return false;
 }

 if (obj1 instanceof RegExp) {
 if (!(obj2 instanceof RegExp &amp;&amp; obj1.source === obj2.source)) {
 return false;
 }
 } 
 else if (obj1 instanceof Date) {
 if (!(obj2 instanceof Date &amp;&amp; obj1.getTime() === obj2.getTime())) {
 return false;
 }
 } 
 else { 
 for (i in obj1) {
 if (obj1.hasOwnProperty(i)) { 
 if (!(obj2.hasOwnProperty(i) &amp;&amp; internalDeepCompare(obj1[i], obj2[i], objects))) {
 return false;
 }
 }
 } 
 }
 break;
 case "function": 
 if (!(typeof obj2 === "function" &amp;&amp; obj1+"" === obj2+"")) {
 return false;
 }
 break;
 default: //deal with NaN 
 if (obj1 !== obj2 &amp;&amp; obj1 === obj1 &amp;&amp; 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);
*/
</code></pre>

blocks|key|1214341|text|var+a=+[1,+2,+3,+'3'];
var+b+=+[1,+2,+3];

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

alert(c.length);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1214342|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var a= [1, 2, 3, '3'];
var b = [1, 2, 3];

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

alert(c.length);
</code></pre>

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

alert(a == b + "|" + b == c);
</code></pre>

<a href="http://jsfiddle.net/YrMyc/3/" rel="noreferrer">demo</a>

How can I check these array for equality and get a method which returns <code>true</code> if they are equal?

Does jQuery offer any method for this?

How to check if two arrays are equal with JavaScript?

var a = [1, 2, 3];var b = [3, 2, 1];var c = new Array(1, 2, 3);alert(a == b + "|" + b == c);如何检查这些数组是否相等，如果它们相等，如何获得返回true的方法？jQuery为此提供了什么方法吗？

问如何用JavaScript检查两个数组是否相等？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何用JavaScript检查两个数组是否相等？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何用JavaScript检查两个数组是否相等？
EN