blocks|key|825370|text|当然，这不是唯一的方法--您可以对一个方法进行原型(这里针对对象，但我肯定不会建议使用Object代码)来复制C#/Java风格的比较方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825371|编辑，因为似乎需要一个一般的例子：|825372|Object.prototype.equals+=+function(x)
{
++++for(p+in+this)
++++{
++++++++switch(typeof(this[p]))
++++++++{
++++++++++++case+'object':
++++++++++++++++if+(!this[p].equals(x[p]))+{+return+false+};+break;
++++++++++++case+'function':
++++++++++++++++if+(typeof(x[p])=='undefined'+%7C%7C+(p+!=+'equals'+&&+this[p].toString()+!=+x[p].toString()))+{+return+false;+};+break;
++++++++++++default:
++++++++++++++++if+(this[p]+!=+x[p])+{+return+false;+}
++++++++}
++++}

++++for(p+in+x)
++++{
++++++++if(typeof(this[p])=='undefined')+{return+false;}
++++}

++++return+true;
}|code-block|syntax|javascript|825373|请注意，使用toString()进行测试的方法绝对不够好，但是一个可以接受的方法非常困难，因为空白有无意义，更不用说用不同的实现产生相同结果的同义词方法和方法了。以及面向对象的原型设计问题。|825374|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Certainly not the only way - you could prototype a method (against Object here but I certainly wouldn't suggest using Object for live code) to replicate C#/Java style comparison methods.

Edit, since a general example seems to be expected:

<pre><code>Object.prototype.equals = function(x)
{
 for(p in this)
 {
 switch(typeof(this[p]))
 {
 case 'object':
 if (!this[p].equals(x[p])) { return false }; break;
 case 'function':
 if (typeof(x[p])=='undefined' || (p != 'equals' &amp;&amp; this[p].toString() != x[p].toString())) { return false; }; break;
 default:
 if (this[p] != x[p]) { return false; }
 }
 }

 for(p in x)
 {
 if(typeof(this[p])=='undefined') {return false;}
 }

 return true;
}
</code></pre>

Note that testing methods with toString() is absolutely not good enough but a method which would be acceptable is very hard because of the problem of whitespace having meaning or not, never mind synonym methods and methods producing the same result with different implementations. And the problems of prototyping against Object in general.

blocks|key|825378|text|如果要显式检查方法，可以使用method.toSource()或method.toString()方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825379|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

if you want to check for methods explicitly you can use the method.toSource() or method.toString() methods.

blocks|key|2351372|text|不幸的是，没有完美的方法，除非您递归地使用_proto_并访问所有不可枚举的属性，但这只适用于火狐。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2351373|所以我所能做的就是猜测使用场景。|2351374|1)快速和有限的.|BOLD|2351375|在没有方法和DOM节点的情况下，如果有简单的JSON样式对象，则可以工作：|2351376|+JSON.stringify(obj1)+===+JSON.stringify(obj2)+|code-block|syntax|javascript|2351377|属性的顺序很重要，因此对于以下对象，此方法将返回false：|2351378|+x+=+{a:+1,+b:+2};
+y+=+{b:+2,+a:+1};|2351379|2)慢且更通用.|2351380|比较对象而不深入原型，然后递归地比较属性的投影，还比较构造函数。|2351381|这几乎是正确的算法：|2351382|function+deepCompare+()+{
++var+i,+l,+leftChain,+rightChain;

++function+compare2Objects+(x,+y)+{
++++var+p;

++++//+remember+that+NaN+===+NaN+returns+false
++++//+and+isNaN(undefined)+returns+true
++++if+(isNaN(x)+&&+isNaN(y)+&&+typeof+x+===+'number'+&&+typeof+y+===+'number')+{
+++++++++return+true;
++++}

++++//+Compare+primitives+and+functions.+++++
++++//+Check+if+both+arguments+link+to+the+same+object.
++++//+Especially+useful+on+the+step+where+we+compare+prototypes
++++if+(x+===+y)+{
++++++++return+true;
++++}

++++//+Works+in+case+when+functions+are+created+in+constructor.
++++//+Comparing+dates+is+a+common+scenario.+Another+built-ins?
++++//+We+can+even+handle+functions+passed+across+iframes
++++if+((typeof+x+===+'function'+&&+typeof+y+===+'function')+%7C%7C
+++++++(x+instanceof+Date+&&+y+instanceof+Date)+%7C%7C
+++++++(x+instanceof+RegExp+&&+y+instanceof+RegExp)+%7C%7C
+++++++(x+instanceof+String+&&+y+instanceof+String)+%7C%7C
+++++++(x+instanceof+Number+&&+y+instanceof+Number))+{
++++++++return+x.toString()+===+y.toString();
++++}

++++//+At+last+checking+prototypes+as+good+as+we+can
++++if+(!(x+instanceof+Object+&&+y+instanceof+Object))+{
++++++++return+false;
++++}

++++if+(x.isPrototypeOf(y)+%7C%7C+y.isPrototypeOf(x))+{
++++++++return+false;
++++}

++++if+(x.constructor+!==+y.constructor)+{
++++++++return+false;
++++}

++++if+(x.prototype+!==+y.prototype)+{
++++++++return+false;
++++}

++++//+Check+for+infinitive+linking+loops
++++if+(leftChain.indexOf(x)+>+-1+%7C%7C+rightChain.indexOf(y)+>+-1)+{
+++++++++return+false;
++++}

++++//+Quick+checking+of+one+object+being+a+subset+of+another.
++++//+todo:+cache+the+structure+of+arguments[0]+for+performance
++++for+(p+in+y)+{
++++++++if+(y.hasOwnProperty(p)+!==+x.hasOwnProperty(p))+{
++++++++++++return+false;
++++++++}
++++++++else+if+(typeof+y[p]+!==+typeof+x[p])+{
++++++++++++return+false;
++++++++}
++++}

++++for+(p+in+x)+{
++++++++if+(y.hasOwnProperty(p)+!==+x.hasOwnProperty(p))+{
++++++++++++return+false;
++++++++}
++++++++else+if+(typeof+y[p]+!==+typeof+x[p])+{
++++++++++++return+false;
++++++++}

++++++++switch+(typeof+(x[p]))+{
++++++++++++case+'object':
++++++++++++case+'function':

++++++++++++++++leftChain.push(x);
++++++++++++++++rightChain.push(y);

++++++++++++++++if+(!compare2Objects+(x[p],+y[p]))+{
++++++++++++++++++++return+false;
++++++++++++++++}

++++++++++++++++leftChain.pop();
++++++++++++++++rightChain.pop();
++++++++++++++++break;

++++++++++++default:
++++++++++++++++if+(x[p]+!==+y[p])+{
++++++++++++++++++++return+false;
++++++++++++++++}
++++++++++++++++break;
++++++++}
++++}

++++return+true;
++}

++if+(arguments.length+<+1)+{
++++return+true;+//Die+silently?+Don't+know+how+to+handle+such+case,+please+help...
++++//+throw+"Need+two+or+more+arguments+to+compare";
++}

++for+(i+=+1,+l+=+arguments.length;+i+<+l;+i%2B%2B)+{

++++++leftChain+=+[];+//Todo:+this+can+be+cached
++++++rightChain+=+[];

++++++if+(!compare2Objects(arguments[0],+arguments[i]))+{
++++++++++return+false;
++++++}
++}

++return+true;
}|2351383|已知的问题(它们的优先级很低，您可能永远不会注意到它们)：|2351384|具有不同原型结构但投影相同的对象|unordered-list-item|2351385|函数可能有相同的文本，但引用不同的闭包。|2351386|测试：通过测试来自https://stackoverflow.com/a/16788517/139361。|2351387|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/16788517/139361^0|L|7|0|0|0|9|0|0|0|0|0|0|8|0|0|0|0|0|0|0|0|3|9|17|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1O|8|@$9|1P|A|1Q|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1R|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1S|8|@]|D|@]|E|$P|Q]]|$1|R|3|S|5|6|7|1T|8|@]|D|@]|E|$]]|$1|T|3|U|5|O|7|1U|8|@]|D|@]|E|$P|Q]]|$1|V|3|W|5|6|7|1V|8|@$9|1W|A|1X|B|J]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|Z|3|10|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|11|3|12|5|O|7|20|8|@]|D|@]|E|$P|Q]]|$1|13|3|14|5|6|7|21|8|@]|D|@]|E|$]]|$1|15|3|16|5|17|7|22|8|@]|D|@]|E|$]]|$1|18|3|19|5|17|7|23|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|6|7|24|8|@$9|25|A|26|B|J]]|D|@$9|27|A|28|1|29]]|E|$]]|$1|1C|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]]|1D|$1E|$5|1F|1G|1H|E|$1I|1J]]]]

Unfortunately there is no perfect way, unless you use <code>_proto_</code> recursively and access all non-enumerable properties, but this works in Firefox only.

So the best I can do is to guess usage scenarios.

<hr>

<h2>1) Fast and limited.</h2>

Works when you have simple JSON-style objects without methods and DOM nodes inside:

<pre><code> JSON.stringify(obj1) === JSON.stringify(obj2) 
</code></pre>

The ORDER of the properties IS IMPORTANT, so this method will return false for following objects:

<pre><code> x = {a: 1, b: 2};
 y = {b: 2, a: 1};
</code></pre>

<hr>

<h2>2) Slow and more generic.</h2>

Compares objects without digging into prototypes, then compares properties' projections recursively, and also compares constructors.

This is almost correct algorithm:

<pre><code>function deepCompare () {
 var i, l, leftChain, rightChain;

 function compare2Objects (x, y) {
 var p;

 // remember that NaN === NaN returns false
 // and isNaN(undefined) returns true
 if (isNaN(x) &amp;&amp; isNaN(y) &amp;&amp; typeof x === 'number' &amp;&amp; typeof y === 'number') {
 return true;
 }

 // Compare primitives and functions. 
 // Check if both arguments link to the same object.
 // Especially useful on the step where we compare prototypes
 if (x === y) {
 return true;
 }

 // Works in case when functions are created in constructor.
 // Comparing dates is a common scenario. Another built-ins?
 // We can even handle functions passed across iframes
 if ((typeof x === 'function' &amp;&amp; typeof y === 'function') ||
 (x instanceof Date &amp;&amp; y instanceof Date) ||
 (x instanceof RegExp &amp;&amp; y instanceof RegExp) ||
 (x instanceof String &amp;&amp; y instanceof String) ||
 (x instanceof Number &amp;&amp; y instanceof Number)) {
 return x.toString() === y.toString();
 }

 // At last checking prototypes as good as we can
 if (!(x instanceof Object &amp;&amp; y instanceof Object)) {
 return false;
 }

 if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
 return false;
 }

 if (x.constructor !== y.constructor) {
 return false;
 }

 if (x.prototype !== y.prototype) {
 return false;
 }

 // Check for infinitive linking loops
 if (leftChain.indexOf(x) &gt; -1 || rightChain.indexOf(y) &gt; -1) {
 return false;
 }

 // Quick checking of one object being a subset of another.
 // todo: cache the structure of arguments[0] for performance
 for (p in y) {
 if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
 return false;
 }
 else if (typeof y[p] !== typeof x[p]) {
 return false;
 }
 }

 for (p in x) {
 if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
 return false;
 }
 else if (typeof y[p] !== typeof x[p]) {
 return false;
 }

 switch (typeof (x[p])) {
 case 'object':
 case 'function':

 leftChain.push(x);
 rightChain.push(y);

 if (!compare2Objects (x[p], y[p])) {
 return false;
 }

 leftChain.pop();
 rightChain.pop();
 break;

 default:
 if (x[p] !== y[p]) {
 return false;
 }
 break;
 }
 }

 return true;
 }

 if (arguments.length &lt; 1) {
 return true; //Die silently? Don't know how to handle such case, please help...
 // throw "Need two or more arguments to compare";
 }

 for (i = 1, l = arguments.length; i &lt; l; i++) {

 leftChain = []; //Todo: this can be cached
 rightChain = [];

 if (!compare2Objects(arguments[0], arguments[i])) {
 return false;
 }
 }

 return true;
}
</code></pre>

Known issues (well, they have very low priority, probably you'll never notice them):

<ul>
<li>objects with different prototype structure but same projection</li>
<li>functions may have identical text but refer to different closures</li>
</ul>

Tests: passes tests are from <a href="https://stackoverflow.com/a/16788517/139361">How to determine equality for two JavaScript objects?</a>.

blocks|key|825440|text|如果您不使用JSON库，这可能有助于解决以下问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825441|Object.prototype.equals+=+function(b)+{
++++var+a+=+this;
++++for(i+in+a)+{
++++++++if(typeof+b[i]+==+'undefined')+{
++++++++++++return+false;
++++++++}
++++++++if(typeof+b[i]+==+'object')+{
++++++++++++if(!b[i].equals(a[i]))+{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++++++if(b[i]+!=+a[i])+{
++++++++++++return+false;
++++++++}
++++}
++++for(i+in+b)+{
++++++++if(typeof+a[i]+==+'undefined')+{
++++++++++++return+false;
++++++++}
++++++++if(typeof+a[i]+==+'object')+{
++++++++++++if(!a[i].equals(b[i]))+{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++++++if(a[i]+!=+b[i])+{
++++++++++++return+false;
++++++++}
++++}
++++return+true;
}

var+a+=+{foo:'bar',+bar:+{blub:'bla'}};
var+b+=+{foo:'bar',+bar:+{blub:'blob'}};
alert(a.equals(b));+//+alert's+a+false|code-block|syntax|javascript|825442|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|$]]

If you work without the JSON library, maybe this will help you out:

<pre><code>Object.prototype.equals = function(b) {
 var a = this;
 for(i in a) {
 if(typeof b[i] == 'undefined') {
 return false;
 }
 if(typeof b[i] == 'object') {
 if(!b[i].equals(a[i])) {
 return false;
 }
 }
 if(b[i] != a[i]) {
 return false;
 }
 }
 for(i in b) {
 if(typeof a[i] == 'undefined') {
 return false;
 }
 if(typeof a[i] == 'object') {
 if(!a[i].equals(b[i])) {
 return false;
 }
 }
 if(a[i] != b[i]) {
 return false;
 }
 }
 return true;
}

var a = {foo:'bar', bar: {blub:'bla'}};
var b = {foo:'bar', bar: {blub:'blob'}};
alert(a.equals(b)); // alert's a false
</code></pre>

blocks|key|944439|text|我修改了上面的代码。对于我来说，0+!==+false和null+!==未定义。如果不需要这样严格的检查，请删除代码中"thisp+!==+xp“中的"=”号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944440|Object.prototype.equals+=+function(x){
++++for+(var+p+in+this)+{
++++++++if(typeof(this[p])+!==+typeof(x[p]))+return+false;
++++++++if((this[p]===null)+!==+(x[p]===null))+return+false;
++++++++switch+(typeof(this[p]))+{
++++++++++++case+'undefined':
++++++++++++++++if+(typeof(x[p])+!=+'undefined')+return+false;
++++++++++++++++break;
++++++++++++case+'object':
++++++++++++++++if(this[p]!==null+&&+x[p]!==null+&&+(this[p].constructor.toString()+!==+x[p].constructor.toString()+%7C%7C+!this[p].equals(x[p])))+return+false;
++++++++++++++++break;
++++++++++++case+'function':
++++++++++++++++if+(p+!=+'equals'+&&+this[p].toString()+!=+x[p].toString())+return+false;
++++++++++++++++break;
++++++++++++default:
++++++++++++++++if+(this[p]+!==+x[p])+return+false;
++++++++}
++++}
++++return+true;
}|code-block|syntax|javascript|944441|然后我用下一个对象测试了它：|944442|var+a+=+{a:+'text',+b:[0,1]};
var+b+=+{a:+'text',+b:[0,1]};
var+c+=+{a:+'text',+b:+0};
var+d+=+{a:+'text',+b:+false};
var+e+=+{a:+'text',+b:[1,0]};
var+f+=+{a:+'text',+b:[1,0],+f:+function(){+this.f+=+this.b;+}};
var+g+=+{a:+'text',+b:[1,0],+f:+function(){+this.f+=+this.b;+}};
var+h+=+{a:+'text',+b:[1,0],+f:+function(){+this.a+=+this.b;+}};
var+i+=+{
++++a:+'text',
++++c:+{
++++++++b:+[1,+0],
++++++++f:+function(){
++++++++++++this.a+=+this.b;
++++++++}
++++}
};
var+j+=+{
++++a:+'text',
++++c:+{
++++++++b:+[1,+0],
++++++++f:+function(){
++++++++++++this.a+=+this.b;
++++++++}
++++}
};
var+k+=+{a:+'text',+b:+null};
var+l+=+{a:+'text',+b:+undefined};|944443|a==b预期为真；返回为真|944444|a==c期望错误；返回错误|944445|c==d期望错误；返回错误|944446|a==e期望错误；返回错误|944447|f==g预期为真；返回为真|944448|h==g期望错误；返回错误|944449|i==j预期为真；返回为真|944450|d==k期望错误；返回错误|944451|k==l期望错误；返回错误|944452|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1F|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1G|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

I have modified a bit the code above. for me 0 !== false and null !== undefined. If you do not need such strict check remove one "=" sign in "this[p] !== x[p]" inside the code.

<pre><code>Object.prototype.equals = function(x){
 for (var p in this) {
 if(typeof(this[p]) !== typeof(x[p])) return false;
 if((this[p]===null) !== (x[p]===null)) return false;
 switch (typeof(this[p])) {
 case 'undefined':
 if (typeof(x[p]) != 'undefined') return false;
 break;
 case 'object':
 if(this[p]!==null &amp;&amp; x[p]!==null &amp;&amp; (this[p].constructor.toString() !== x[p].constructor.toString() || !this[p].equals(x[p]))) return false;
 break;
 case 'function':
 if (p != 'equals' &amp;&amp; this[p].toString() != x[p].toString()) return false;
 break;
 default:
 if (this[p] !== x[p]) return false;
 }
 }
 return true;
}
</code></pre>

Then I have tested it with next objects:

<pre><code>var a = {a: 'text', b:[0,1]};
var b = {a: 'text', b:[0,1]};
var c = {a: 'text', b: 0};
var d = {a: 'text', b: false};
var e = {a: 'text', b:[1,0]};
var f = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
var g = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
var h = {a: 'text', b:[1,0], f: function(){ this.a = this.b; }};
var i = {
 a: 'text',
 c: {
 b: [1, 0],
 f: function(){
 this.a = this.b;
 }
 }
};
var j = {
 a: 'text',
 c: {
 b: [1, 0],
 f: function(){
 this.a = this.b;
 }
 }
};
var k = {a: 'text', b: null};
var l = {a: 'text', b: undefined};
</code></pre>

a==b expected true; returned true

a==c expected false; returned false

c==d expected false; returned false

a==e expected false; returned false

f==g expected true; returned true

h==g expected false; returned false

i==j expected true; returned true

d==k expected false; returned false

k==l expected false; returned false

blocks|key|825476|text|我为对象比较编写了这段代码，它似乎很有效。检查断言：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|825477|function+countProps(obj)+{
++++var+count+=+0;
++++for+(k+in+obj)+{
++++++++if+(obj.hasOwnProperty(k))+{
++++++++++++count%2B%2B;
++++++++}
++++}
++++return+count;
};

function+objectEquals(v1,+v2)+{

++++if+(typeof(v1)+!==+typeof(v2))+{
++++++++return+false;
++++}

++++if+(typeof(v1)+===+"function")+{
++++++++return+v1.toString()+===+v2.toString();
++++}

++++if+(v1+instanceof+Object+&&+v2+instanceof+Object)+{
++++++++if+(countProps(v1)+!==+countProps(v2))+{
++++++++++++return+false;
++++++++}
++++++++var+r+=+true;
++++++++for+(k+in+v1)+{
++++++++++++r+=+objectEquals(v1[k],+v2[k]);
++++++++++++if+(!r)+{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++++++return+true;
++++}+else+{
++++++++return+v1+===+v2;
++++}
}

assert.isTrue(objectEquals(null,null));
assert.isFalse(objectEquals(null,undefined));

assert.isTrue(objectEquals("hi","hi"));
assert.isTrue(objectEquals(5,5));
assert.isFalse(objectEquals(5,10));

assert.isTrue(objectEquals([],[]));
assert.isTrue(objectEquals([1,2],[1,2]));
assert.isFalse(objectEquals([1,2],[2,1]));
assert.isFalse(objectEquals([1,2],[1,2,3]));

assert.isTrue(objectEquals({},{}));
assert.isTrue(objectEquals({a:1,b:2},{a:1,b:2}));
assert.isTrue(objectEquals({a:1,b:2},{b:2,a:1}));
assert.isFalse(objectEquals({a:1,b:2},{a:1,b:3}));

assert.isTrue(objectEquals({1:{name:"mhc",age:28},+2:{name:"arb",age:26}},{1:{name:"mhc",age:28},+2:{name:"arb",age:26}}));
assert.isFalse(objectEquals({1:{name:"mhc",age:28},+2:{name:"arb",age:26}},{1:{name:"mhc",age:28},+2:{name:"arb",age:27}}));

assert.isTrue(objectEquals(function(x){return+x;},function(x){return+x;}));
assert.isFalse(objectEquals(function(x){return+x;},function(y){return+y%2B2;}));|code-block|syntax|javascript|825478|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|$]]

I wrote this piece of code for object comparison, and it seems to work. check the assertions:

<pre><code>
function countProps(obj) {
 var count = 0;
 for (k in obj) {
 if (obj.hasOwnProperty(k)) {
 count++;
 }
 }
 return count;
};

function objectEquals(v1, v2) {

 if (typeof(v1) !== typeof(v2)) {
 return false;
 }

 if (typeof(v1) === "function") {
 return v1.toString() === v2.toString();
 }

 if (v1 instanceof Object && v2 instanceof Object) {
 if (countProps(v1) !== countProps(v2)) {
 return false;
 }
 var r = true;
 for (k in v1) {
 r = objectEquals(v1[k], v2[k]);
 if (!r) {
 return false;
 }
 }
 return true;
 } else {
 return v1 === v2;
 }
}

assert.isTrue(objectEquals(null,null));
assert.isFalse(objectEquals(null,undefined));

assert.isTrue(objectEquals("hi","hi"));
assert.isTrue(objectEquals(5,5));
assert.isFalse(objectEquals(5,10));

assert.isTrue(objectEquals([],[]));
assert.isTrue(objectEquals([1,2],[1,2]));
assert.isFalse(objectEquals([1,2],[2,1]));
assert.isFalse(objectEquals([1,2],[1,2,3]));

assert.isTrue(objectEquals({},{}));
assert.isTrue(objectEquals({a:1,b:2},{a:1,b:2}));
assert.isTrue(objectEquals({a:1,b:2},{b:2,a:1}));
assert.isFalse(objectEquals({a:1,b:2},{a:1,b:3}));

assert.isTrue(objectEquals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}},{1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}));
assert.isFalse(objectEquals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}},{1:{name:"mhc",age:28}, 2:{name:"arb",age:27}}));

assert.isTrue(objectEquals(function(x){return x;},function(x){return x;}));
assert.isFalse(objectEquals(function(x){return x;},function(y){return y+2;}));
</code></pre>

blocks|key|2351454|text|下面是我的版本，这个线程中的大部分内容都是集成的(测试用例的计数相同)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2351455|Object.defineProperty(Object.prototype,+"equals",+{
++++enumerable:+false,
++++value:+function+(obj)+{
++++++++var+p;
++++++++if+(this+===+obj)+{
++++++++++++return+true;
++++++++}

++++++++//+some+checks+for+native+types+first

++++++++//+function+and+sring
++++++++if+(typeof(this)+===+"function"+%7C%7C+typeof(this)+===+"string"+%7C%7C+this+instanceof+String)+{+
++++++++++++return+this.toString()+===+obj.toString();
++++++++}

++++++++//+number
++++++++if+(this+instanceof+Number+%7C%7C+typeof(this)+===+"number")+{
++++++++++++if+(obj+instanceof+Number+%7C%7C+typeof(obj)+===+"number")+{
++++++++++++++++return+this.valueOf()+===+obj.valueOf();
++++++++++++}
++++++++++++return+false;
++++++++}

++++++++//+null.equals(null)+and+undefined.equals(undefined)+do+not+inherit+from+the+
++++++++//+Object.prototype+so+we+can+return+false+when+they+are+passed+as+obj
++++++++if+(typeof(this)+!==+typeof(obj)+%7C%7C+obj+===+null+%7C%7C+typeof(obj)+===+"undefined")+{
++++++++++++return+false;
++++++++}

++++++++function+sort+(o)+{
++++++++++++var+result+=+{};

++++++++++++if+(typeof+o+!==+"object")+{
++++++++++++++++return+o;
++++++++++++}

++++++++++++Object.keys(o).sort().forEach(function+(key)+{
++++++++++++++++result[key]+=+sort(o[key]);
++++++++++++});

++++++++++++return+result;
++++++++}

++++++++if+(typeof(this)+===+"object")+{
++++++++++++if+(Array.isArray(this))+{+//+check+on+arrays
++++++++++++++++return+JSON.stringify(this)+===+JSON.stringify(obj);++++++++++++++++
++++++++++++}+else+{+//+anyway+objects
++++++++++++++++for+(p+in+this)+{
++++++++++++++++++++if+(typeof(this[p])+!==+typeof(obj[p]))+{
++++++++++++++++++++++++return+false;
++++++++++++++++++++}
++++++++++++++++++++if+((this[p]+===+null)+!==+(obj[p]+===+null))+{
++++++++++++++++++++++++return+false;
++++++++++++++++++++}
++++++++++++++++++++switch+(typeof(this[p]))+{
++++++++++++++++++++case+'undefined':
++++++++++++++++++++++++if+(typeof(obj[p])+!==+'undefined')+{
++++++++++++++++++++++++++++return+false;
++++++++++++++++++++++++}
++++++++++++++++++++++++break;
++++++++++++++++++++case+'object':
++++++++++++++++++++++++if+(this[p]+!==+null+
++++++++++++++++++++++++++++++++&&+obj[p]+!==+null+
++++++++++++++++++++++++++++++++&&+(this[p].constructor.toString()+!==+obj[p].constructor.toString()+
++++++++++++++++++++++++++++++++++++++++%7C%7C+!this[p].equals(obj[p])))+{
++++++++++++++++++++++++++++return+false;
++++++++++++++++++++++++}
++++++++++++++++++++++++break;
++++++++++++++++++++case+'function':
++++++++++++++++++++++++if+(this[p].toString()+!==+obj[p].toString())+{
++++++++++++++++++++++++++++return+false;
++++++++++++++++++++++++}
++++++++++++++++++++++++break;
++++++++++++++++++++default:
++++++++++++++++++++++++if+(this[p]+!==+obj[p])+{
++++++++++++++++++++++++++++return+false;
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++};

++++++++++++}
++++++++}

++++++++//+at+least+check+them+with+JSON
++++++++return+JSON.stringify(sort(this))+===+JSON.stringify(sort(obj));
++++}
});|code-block|syntax|javascript|2351456|这是我的TestCase：|2351457|++++assertFalse({}.equals(null));
++++assertFalse({}.equals(undefined));

++++assertTrue("String",+"hi".equals("hi"));
++++assertTrue("Number",+new+Number(5).equals(5));
++++assertFalse("Number",+new+Number(5).equals(10));
++++assertFalse("Number%2BString",+new+Number(1).equals("1"));

++++assertTrue([].equals([]));
++++assertTrue([1,2].equals([1,2]));
++++assertFalse([1,2].equals([2,1]));
++++assertFalse([1,2].equals([1,2,3]));

++++assertTrue(new+Date("2011-03-31").equals(new+Date("2011-03-31")));
++++assertFalse(new+Date("2011-03-31").equals(new+Date("1970-01-01")));

++++assertTrue({}.equals({}));
++++assertTrue({a:1,b:2}.equals({a:1,b:2}));
++++assertTrue({a:1,b:2}.equals({b:2,a:1}));
++++assertFalse({a:1,b:2}.equals({a:1,b:3}));

++++assertTrue({1:{name:"mhc",age:28},+2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28},+2:{name:"arb",age:26}}));
++++assertFalse({1:{name:"mhc",age:28},+2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28},+2:{name:"arb",age:27}}));

++++assertTrue("Function",+(function(x){return+x;}).equals(function(x){return+x;}));
++++assertFalse("Function",+(function(x){return+x;}).equals(function(y){return+y%2B2;}));

++++var+a+=+{a:+'text',+b:[0,1]};
++++var+b+=+{a:+'text',+b:[0,1]};
++++var+c+=+{a:+'text',+b:+0};
++++var+d+=+{a:+'text',+b:+false};
++++var+e+=+{a:+'text',+b:[1,0]};
++++var+f+=+{a:+'text',+b:[1,0],+f:+function(){+this.f+=+this.b;+}};
++++var+g+=+{a:+'text',+b:[1,0],+f:+function(){+this.f+=+this.b;+}};
++++var+h+=+{a:+'text',+b:[1,0],+f:+function(){+this.a+=+this.b;+}};
++++var+i+=+{
++++++++a:+'text',
++++++++c:+{
++++++++++++b:+[1,+0],
++++++++++++f:+function(){
++++++++++++++++this.a+=+this.b;
++++++++++++}
++++++++}
++++};
++++var+j+=+{
++++++++a:+'text',
++++++++c:+{
++++++++++++b:+[1,+0],
++++++++++++f:+function(){
++++++++++++++++this.a+=+this.b;
++++++++++++}
++++++++}
++++};
++++var+k+=+{a:+'text',+b:+null};
++++var+l+=+{a:+'text',+b:+undefined};

++++assertTrue(a.equals(b));
++++assertFalse(a.equals(c));
++++assertFalse(c.equals(d));
++++assertFalse(a.equals(e));
++++assertTrue(f.equals(g));
++++assertFalse(h.equals(g));
++++assertTrue(i.equals(j));
++++assertFalse(d.equals(k));
++++assertFalse(k.equals(l));|2351458|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is my version, pretty much stuff from this thread is integrated (same counts for the test cases):

<pre><code>Object.defineProperty(Object.prototype, "equals", {
 enumerable: false,
 value: function (obj) {
 var p;
 if (this === obj) {
 return true;
 }

 // some checks for native types first

 // function and sring
 if (typeof(this) === "function" || typeof(this) === "string" || this instanceof String) { 
 return this.toString() === obj.toString();
 }

 // number
 if (this instanceof Number || typeof(this) === "number") {
 if (obj instanceof Number || typeof(obj) === "number") {
 return this.valueOf() === obj.valueOf();
 }
 return false;
 }

 // null.equals(null) and undefined.equals(undefined) do not inherit from the 
 // Object.prototype so we can return false when they are passed as obj
 if (typeof(this) !== typeof(obj) || obj === null || typeof(obj) === "undefined") {
 return false;
 }

 function sort (o) {
 var result = {};

 if (typeof o !== "object") {
 return o;
 }

 Object.keys(o).sort().forEach(function (key) {
 result[key] = sort(o[key]);
 });

 return result;
 }

 if (typeof(this) === "object") {
 if (Array.isArray(this)) { // check on arrays
 return JSON.stringify(this) === JSON.stringify(obj); 
 } else { // anyway objects
 for (p in this) {
 if (typeof(this[p]) !== typeof(obj[p])) {
 return false;
 }
 if ((this[p] === null) !== (obj[p] === null)) {
 return false;
 }
 switch (typeof(this[p])) {
 case 'undefined':
 if (typeof(obj[p]) !== 'undefined') {
 return false;
 }
 break;
 case 'object':
 if (this[p] !== null 
 &amp;&amp; obj[p] !== null 
 &amp;&amp; (this[p].constructor.toString() !== obj[p].constructor.toString() 
 || !this[p].equals(obj[p]))) {
 return false;
 }
 break;
 case 'function':
 if (this[p].toString() !== obj[p].toString()) {
 return false;
 }
 break;
 default:
 if (this[p] !== obj[p]) {
 return false;
 }
 }
 };

 }
 }

 // at least check them with JSON
 return JSON.stringify(sort(this)) === JSON.stringify(sort(obj));
 }
});
</code></pre>

Here is my TestCase:

<pre><code> assertFalse({}.equals(null));
 assertFalse({}.equals(undefined));

 assertTrue("String", "hi".equals("hi"));
 assertTrue("Number", new Number(5).equals(5));
 assertFalse("Number", new Number(5).equals(10));
 assertFalse("Number+String", new Number(1).equals("1"));

 assertTrue([].equals([]));
 assertTrue([1,2].equals([1,2]));
 assertFalse([1,2].equals([2,1]));
 assertFalse([1,2].equals([1,2,3]));

 assertTrue(new Date("2011-03-31").equals(new Date("2011-03-31")));
 assertFalse(new Date("2011-03-31").equals(new Date("1970-01-01")));

 assertTrue({}.equals({}));
 assertTrue({a:1,b:2}.equals({a:1,b:2}));
 assertTrue({a:1,b:2}.equals({b:2,a:1}));
 assertFalse({a:1,b:2}.equals({a:1,b:3}));

 assertTrue({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}));
 assertFalse({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28}, 2:{name:"arb",age:27}}));

 assertTrue("Function", (function(x){return x;}).equals(function(x){return x;}));
 assertFalse("Function", (function(x){return x;}).equals(function(y){return y+2;}));

 var a = {a: 'text', b:[0,1]};
 var b = {a: 'text', b:[0,1]};
 var c = {a: 'text', b: 0};
 var d = {a: 'text', b: false};
 var e = {a: 'text', b:[1,0]};
 var f = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
 var g = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
 var h = {a: 'text', b:[1,0], f: function(){ this.a = this.b; }};
 var i = {
 a: 'text',
 c: {
 b: [1, 0],
 f: function(){
 this.a = this.b;
 }
 }
 };
 var j = {
 a: 'text',
 c: {
 b: [1, 0],
 f: function(){
 this.a = this.b;
 }
 }
 };
 var k = {a: 'text', b: null};
 var l = {a: 'text', b: undefined};

 assertTrue(a.equals(b));
 assertFalse(a.equals(c));
 assertFalse(c.equals(d));
 assertFalse(a.equals(e));
 assertTrue(f.equals(g));
 assertFalse(h.equals(g));
 assertTrue(i.equals(j));
 assertFalse(d.equals(k));
 assertFalse(k.equals(l));
</code></pre>

blocks|key|2351469|text|++Utils.compareObjects+=+function(o1,+o2){
++++for(var+p+in+o1){
++++++++if(o1.hasOwnProperty(p)){
++++++++++++if(o1[p]+!==+o2[p]){
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++}
++++for(var+p+in+o2){
++++++++if(o2.hasOwnProperty(p)){
++++++++++++if(o1[p]+!==+o2[p]){
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++}
++++return+true;
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2351470|比较单一级别对象的简单方法。|unstyled|2351471|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code> Utils.compareObjects = function(o1, o2){
 for(var p in o1){
 if(o1.hasOwnProperty(p)){
 if(o1[p] !== o2[p]){
 return false;
 }
 }
 }
 for(var p in o2){
 if(o2.hasOwnProperty(p)){
 if(o1[p] !== o2[p]){
 return false;
 }
 }
 }
 return true;
};
</code></pre>

Simple way to compare ONE-LEVEL only objects.

blocks|key|943758|text|以下算法将处理自引用数据结构、数字、字符串、日期，当然还有简单嵌套的javascript对象：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|943759|对象被认为是等效的。|943760|它们与每个===完全相等(字符串和数字首先被展开，以确保42等同于Number(42))|unordered-list-item|offset|length|style|CODE|943761|或者它们都是日期，具有相同的valueOf()|943762|或者他们都是同一类型而不是空的和..。|943763|它们不是对象，每个==+(捕获数/字符串/布尔值)相等。|943764|或者，忽略具有undefined值的属性，它们具有相同的属性，所有这些属性都被认为是递归等价的。|943765|943766|​|943767|函数被函数文本认为是不相同的。这个测试是不够的，因为函数可能有不同的闭包。只有当===这么说的时候，函数才被认为是相等的(但是如果你选择这样做的话，你可以很容易地扩展这个等价的关系)。|BOLD|943768|避免了由循环数据结构引起的无限环。当areEquivalent试图推翻等式并递归到对象的属性中时，它会跟踪需要进行子比较的对象。如果可以否定相等，则对象之间的某些可达属性路径不同，则必须有最短的此类可达路径，且最短可达路径不能包含这两条路径中存在的循环；也就是说，当递归比较对象时，可以假定相等。假设存储在属性areEquivalent_Eq_91_2_34中，该属性在使用后被删除，但是如果对象图已经包含这样的属性，则行为是未定义的。使用这样的标记属性是必要的，因为javascript不支持使用任意对象作为键的字典。|943769|function+unwrapStringOrNumber(obj)+{
++++return+(obj+instanceof+Number+%7C%7C+obj+instanceof+String+
++++++++++++?+obj.valueOf()+
++++++++++++:+obj);
}
function+areEquivalent(a,+b)+{
++++a+=+unwrapStringOrNumber(a);
++++b+=+unwrapStringOrNumber(b);
++++if+(a+===+b)+return+true;+//e.g.+a+and+b+both+null
++++if+(a+===+null+%7C%7C+b+===+null+%7C%7C+typeof+(a)+!==+typeof+(b))+return+false;
++++if+(a+instanceof+Date)+
++++++++return+b+instanceof+Date+&&+a.valueOf()+===+b.valueOf();
++++if+(typeof+(a)+!==+"object")+
++++++++return+a+==+b;+//for+boolean,+number,+string,+xml

++++var+newA+=+(a.areEquivalent_Eq_91_2_34+===+undefined),
++++++++newB+=+(b.areEquivalent_Eq_91_2_34+===+undefined);
++++try+{
++++++++if+(newA)+a.areEquivalent_Eq_91_2_34+=+[];
++++++++else+if+(a.areEquivalent_Eq_91_2_34.some(
++++++++++++function+(other)+{+return+other+===+b;+}))+return+true;
++++++++if+(newB)+b.areEquivalent_Eq_91_2_34+=+[];
++++++++else+if+(b.areEquivalent_Eq_91_2_34.some(
++++++++++++function+(other)+{+return+other+===+a;+}))+return+true;
++++++++a.areEquivalent_Eq_91_2_34.push(b);
++++++++b.areEquivalent_Eq_91_2_34.push(a);

++++++++var+tmp+=+{};
++++++++for+(var+prop+in+a)+
++++++++++++if(prop+!=+"areEquivalent_Eq_91_2_34")+
++++++++++++++++tmp[prop]+=+null;
++++++++for+(var+prop+in+b)+
++++++++++++if+(prop+!=+"areEquivalent_Eq_91_2_34")+
++++++++++++++++tmp[prop]+=+null;

++++++++for+(var+prop+in+tmp)+
++++++++++++if+(!areEquivalent(a[prop],+b[prop]))
++++++++++++++++return+false;
++++++++return+true;
++++}+finally+{
++++++++if+(newA)+delete+a.areEquivalent_Eq_91_2_34;
++++++++if+(newB)+delete+b.areEquivalent_Eq_91_2_34;
++++}
}|code-block|syntax|javascript|943770|entityMap^0|0|0|5|3|S|2|X|A|0|E|9|0|1|9|2|1|7|9|1|0|0|0|2|14|3|0|D|3|I|D|4B|O|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|19|8|@$G|1A|H|1B|I|J]|$G|1C|H|1D|I|J]|$G|1E|H|1F|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|1G|8|@$G|1H|H|1I|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|1J|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1K|8|@$G|1L|H|1M|I|J]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1N|8|@$G|1O|H|1P|I|J]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1R|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1S|8|@$G|1T|H|1U|I|X]|$G|1V|H|1W|I|J]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1X|8|@$G|1Y|H|1Z|I|X]|$G|20|H|21|I|J]|$G|22|H|23|I|J]]|9|@]|A|$]]|$1|10|3|11|5|12|7|24|8|@]|9|@]|A|$13|14]]|$1|15|3|-4|5|6|7|25|8|@]|9|@]|A|$]]]|16|$]]

The following algorithm will deal with self-referential data structures, numbers, strings, dates, and of course plain nested javascript objects:

Objects are considered equivalent when

<ul>
<li>They are exactly equal per <code>===</code> (String and Number are unwrapped first to ensure <code>42</code> is equivalent to <code>Number(42)</code>)</li>
<li>or they are both dates and have the same <code>valueOf()</code></li>
<li>or they are both of the same type and not null and...
<ul>
<li>they are not objects and are equal per <code>==</code> (catches numbers/strings/booleans)</li>
<li>or, ignoring properties with <code>undefined</code> value they have the same properties all of which are considered recursively equivalent.</li>
</ul></li>
</ul>

Functions are not considered identical by function text. This test is insufficient because functions may have differing closures. Functions are only considered equal if <code>===</code> says so (but you could easily extend that equivalent relation should you choose to do so).

Infinite loops, potentially caused by circular datastructures, are avoided. When <code>areEquivalent</code> attempts to disprove equality and recurses into an object's properties to do so, it keeps track of the objects for which this sub-comparison is needed. If equality can be disproved, then some reachable property path differs between the objects, and then there must be a shortest such reachable path, and that shortest reachable path cannot contain cycles present in both paths; i.e. it is OK to assume equality when recursively comparing objects. The assumption is stored in a property <code>areEquivalent_Eq_91_2_34</code>, which is deleted after use, but if the object graph already contains such a property, behavior is undefined. The use of such a marker property is necessary because javascript doesn't support dictionaries using arbitrary objects as keys.

<pre><code>function unwrapStringOrNumber(obj) {
 return (obj instanceof Number || obj instanceof String 
 ? obj.valueOf() 
 : obj);
}
function areEquivalent(a, b) {
 a = unwrapStringOrNumber(a);
 b = unwrapStringOrNumber(b);
 if (a === b) return true; //e.g. a and b both null
 if (a === null || b === null || typeof (a) !== typeof (b)) return false;
 if (a instanceof Date) 
 return b instanceof Date &amp;&amp; a.valueOf() === b.valueOf();
 if (typeof (a) !== "object") 
 return a == b; //for boolean, number, string, xml

 var newA = (a.areEquivalent_Eq_91_2_34 === undefined),
 newB = (b.areEquivalent_Eq_91_2_34 === undefined);
 try {
 if (newA) a.areEquivalent_Eq_91_2_34 = [];
 else if (a.areEquivalent_Eq_91_2_34.some(
 function (other) { return other === b; })) return true;
 if (newB) b.areEquivalent_Eq_91_2_34 = [];
 else if (b.areEquivalent_Eq_91_2_34.some(
 function (other) { return other === a; })) return true;
 a.areEquivalent_Eq_91_2_34.push(b);
 b.areEquivalent_Eq_91_2_34.push(a);

 var tmp = {};
 for (var prop in a) 
 if(prop != "areEquivalent_Eq_91_2_34") 
 tmp[prop] = null;
 for (var prop in b) 
 if (prop != "areEquivalent_Eq_91_2_34") 
 tmp[prop] = null;

 for (var prop in tmp) 
 if (!areEquivalent(a[prop], b[prop]))
 return false;
 return true;
 } finally {
 if (newA) delete a.areEquivalent_Eq_91_2_34;
 if (newB) delete b.areEquivalent_Eq_91_2_34;
 }
}
</code></pre>

blocks|key|943802|text|下面是我的ES3注释解决方案(代码后面的血淋淋的细节)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|943803|function+object_equals(+x,+y+)+{
++if+(+x+===+y+)+return+true;
++++//+if+both+x+and+y+are+null+or+undefined+and+exactly+the+same

++if+(+!+(+x+instanceof+Object+)+%7C%7C+!+(+y+instanceof+Object+)+)+return+false;
++++//+if+they+are+not+strictly+equal,+they+both+need+to+be+Objects

++if+(+x.constructor+!==+y.constructor+)+return+false;
++++//+they+must+have+the+exact+same+prototype+chain,+the+closest+we+can+do+is
++++//+test+there+constructor.

++for+(+var+p+in+x+)+{
++++if+(+!+x.hasOwnProperty(+p+)+)+continue;
++++++//+other+properties+were+tested+using+x.constructor+===+y.constructor

++++if+(+!+y.hasOwnProperty(+p+)+)+return+false;
++++++//+allows+to+compare+x[+p+]+and+y[+p+]+when+set+to+undefined

++++if+(+x[+p+]+===+y[+p+]+)+continue;
++++++//+if+they+have+the+same+strict+value+or+identity+then+they+are+equal

++++if+(+typeof(+x[+p+]+)+!==+"object"+)+return+false;
++++++//+Numbers,+Strings,+Functions,+Booleans+must+be+strictly+equal

++++if+(+!+object_equals(+x[+p+],++y[+p+]+)+)+return+false;
++++++//+Objects+and+Arrays+must+be+tested+recursively
++}

++for+(+p+in+y+)
++++if+(+y.hasOwnProperty(+p+)+&&+!+x.hasOwnProperty(+p+)+)
++++++return+false;
++++++++//+allows+x[+p+]+to+be+set+to+undefined

++return+true;
}|code-block|syntax|javascript|943804|在开发这个解决方案的过程中，我特别关注了一些角落案例，效率，但我仍然试图给出一个简单的解决方案，希望能用一些优雅的方法来实现。JavaScript允许空和未定义的属性，对象具有原型链，如果不进行检查，会导致非常不同的行为。|943805|首先，我选择不扩展Object.prototype，，主要是因为空不能是比较的对象之一，而且我认为空应该是与另一个对象进行比较的有效对象。对于Object.prototype的扩展，还有其他人对其他代码可能产生的副作用的其他合理关注。|943806|必须特别注意JavaScript允许将对象属性设置为未定义的可能性，即存在将值设置为未定义的属性。上面的解决方案验证两个对象是否具有相同的属性设置为未定义的以报告相等。这只能通过使用Object.hasOwnProperty(+property_name+)检查属性的存在来实现。还请注意，JSON.stringify()移除设置为未定义的属性，因此使用此表单进行比较将忽略设置为值未定义的属性。|943807|只有当函数共享相同的引用，而不仅仅是相同的代码时，函数才会被认为是相等的，因为这不会考虑到这些函数原型。因此，比较代码字符串并不能保证它们具有相同的原型对象。|943808|这两个对象应该具有相同的原型链，而不仅仅是相同的属性。这只能通过比较两个对象的构造函数(严格相等)来测试跨浏览器。Object.getPrototypeOf().+5将允许使用ECMAScript测试它们的实际原型。一些web浏览器还提供了一个__proto__属性来完成同样的任务。如果对上述代码进行可能的改进，就可以随时使用这些方法中的一种。|943809|在这里使用严格的比较是非常重要的，因为2不应该被认为等于"2.0000"，也不应该认为false等于null、未定义的<代码>E+248或E+149E+250。|CODE|943810|效率方面的考虑促使我尽快比较属性的相等性。然后，只有在失败的情况下，查找类型的--这些属性。对于具有大量标量特性的大对象，速度提升可能是显着的。|943811|不再需要两个循环，第一个循环检查左对象的属性，第二个循环检查右边的属性并验证是否存在(而不是值)，以捕获使用未定义的值定义的这些属性。|943812|总的来说，这段代码只处理了16行代码(没有注释)中的大多数拐角情况。|943813|更新(8/13/2015)。我已经实现了一个更好的版本，作为速度更快的函数等于()，可以正确地处理诸如NaN和与-0不同的0这样的角情况，还可以强制对象的属性顺序和循环引用的测试，作为图布卡尔项目测试套件的一部分，由多个100次自动测试支持。|943814|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ReactiveSets/toubkal/blob/master/lib/util/value_equals.js|1|https://github.com/ReactiveSets/toubkal|2|https://github.com/ReactiveSets/toubkal/blob/master/test/src/value_equals.coffee^0|5|3|0|0|23|1|25|4|2G|3|0|9|G|W|1|1D|1|1Z|G|0|Q|3|16|3|22|4|2J|12|41|G|4M|3|5B|3|0|0|C|3|13|4|1L|N|3E|9|0|J|1|S|8|17|5|1E|4|1J|P|1X|A|0|0|20|0|0|1V|0|0|Y|0|0|3D|11|4|0|2K|4|1|32|8|2|0^^$0|@$1|2|3|4|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|21|8|@$9|22|A|23|B|C]|$9|24|A|25|B|C]|$9|26|A|27|B|C]|$9|28|A|29|B|C]|$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]|$9|2E|A|2F|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2G|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|2H|8|@$9|2I|A|2J|B|C]|$9|2K|A|2L|B|C]|$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|2Q|8|@$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]|$9|2X|A|2Y|B|C]|$9|2Z|A|30|B|C]|$9|31|A|32|B|W]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|33|8|@$9|34|A|35|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|36|8|@$9|37|A|38|B|C]]|D|@]|E|$]]|$1|11|3|12|5|6|7|39|8|@$9|3A|A|3B|B|C]]|D|@]|E|$]]|$1|13|3|14|5|6|7|3C|8|@$9|3D|A|3E|B|C]]|D|@$9|3F|A|3G|1|3H]|$9|3I|A|3J|1|3K]|$9|3L|A|3M|1|3N]]|E|$]]|$1|15|3|-4|5|6|7|3O|8|@]|D|@]|E|$]]]|16|$17|$5|18|19|1A|E|$1B|1C]]|1D|$5|18|19|1A|E|$1B|1E]]|1F|$5|18|19|1A|E|$1B|1G]]]]

Here is my ES3 commented solution (gory details after the code):

<pre><code>function object_equals( x, y ) {
 if ( x === y ) return true;
 // if both x and y are null or undefined and exactly the same

 if ( ! ( x instanceof Object ) || ! ( y instanceof Object ) ) return false;
 // if they are not strictly equal, they both need to be Objects

 if ( x.constructor !== y.constructor ) return false;
 // they must have the exact same prototype chain, the closest we can do is
 // test there constructor.

 for ( var p in x ) {
 if ( ! x.hasOwnProperty( p ) ) continue;
 // other properties were tested using x.constructor === y.constructor

 if ( ! y.hasOwnProperty( p ) ) return false;
 // allows to compare x[ p ] and y[ p ] when set to undefined

 if ( x[ p ] === y[ p ] ) continue;
 // if they have the same strict value or identity then they are equal

 if ( typeof( x[ p ] ) !== "object" ) return false;
 // Numbers, Strings, Functions, Booleans must be strictly equal

 if ( ! object_equals( x[ p ], y[ p ] ) ) return false;
 // Objects and Arrays must be tested recursively
 }

 for ( p in y )
 if ( y.hasOwnProperty( p ) &amp;&amp; ! x.hasOwnProperty( p ) )
 return false;
 // allows x[ p ] to be set to undefined

 return true;
}
</code></pre>

In developing this solution, I took a particular look at corner cases, efficiency, yet trying to yield a simple solution that works, hopefully with some elegance. JavaScript allows both null and undefined properties and objects have prototypes chains that can lead to very different behaviors if not checked.

First I have chosen to not extend Object.prototype, mostly because null could not be one of the objects of the comparison and that I believe that null should be a valid object to compare with another. There are also other legitimate concerns noted by others regarding the extension of Object.prototype regarding possible side effects on other's code.

Special care must taken to deal the possibility that JavaScript allows object properties can be set to undefined, i.e. there exists properties which values are set to undefined. The above solution verifies that both objects have the same properties set to undefined to report equality. This can only be accomplished by checking the existence of properties using Object.hasOwnProperty( property_name ). Also note that JSON.stringify() removes properties that are set to undefined, and that therefore comparisons using this form will ignore properties set to the value undefined. 

Functions should be considered equal only if they share the same reference, not just the same code, because this would not take into account these functions prototype. So comparing the code string does not work to guaranty that they have the same prototype object.

The two objects should have the same prototype chain, not just the same properties. This can only be tested cross-browser by comparing the constructor of both objects for strict equality. ECMAScript 5 would allow to test their actual prototype using Object.getPrototypeOf(). Some web browsers also offer a __proto__ property that does the same thing. A possible improvement of the above code would allow to use one of these methods whenever available.

The use of strict comparisons is paramount here because 2 should not be considered equal to "2.0000", nor false should be considered equal to null, undefined, or 0.

Efficiency considerations lead me to compare for equality of properties as soon as possible. Then, only if that failed, look for the typeof these properties. The speed boost could be significant on large objects with lots of scalar properties.

No more that two loops are required, the first to check properties from the left object, the second to check properties from the right and verify only existence (not value), to catch these properties which are defined with the undefined value.

Overall this code handles most corner cases in only 16 lines of code (without comments).

<hr>

Update (8/13/2015). I have implemented a better version, as the function <a href="https://github.com/ReactiveSets/toubkal/blob/master/lib/util/value_equals.js" rel="noreferrer">value_equals()</a> that is faster, handles properly corner cases such as NaN and 0 different than -0, optionally enforcing objects' properties order and testing for cyclic references, backed by more than <a href="https://github.com/ReactiveSets/toubkal/blob/master/test/src/value_equals.coffee" rel="noreferrer">100 automated tests</a> as part of the <a href="https://github.com/ReactiveSets/toubkal" rel="noreferrer">Toubkal</a> project test suite.

What is the best way to compare objects in JavaScript?

Example:

<pre><code>var user1 = {name : "nerd", org: "dev"};
var user2 = {name : "nerd", org: "dev"};
var eq = user1 == user2;
alert(eq); // gives false
</code></pre>

I know that two objects are equal if they refer to the exact same object, but is there a way to check if they have the same attributes' values?

The following way works for me, but is it the only possibility?

<pre><code>var eq = Object.toJSON(user1) == Object.toJSON(user2);
alert(eq); // gives true
</code></pre>

Object comparison in JavaScript

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在JavaScript中比较对象的最佳方法是什么？示例：var user1 = {name : "nerd", org: "dev"};var user2 = {name : "nerd", org: "dev"};var eq = user1 == user2;alert(eq); // gives false我知道...

问JavaScript中的对象比较
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的对象比较EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的对象比较
EN