How to determine equality for two JavaScript objects

Question

A strict equality operator will tell you if two object types are equal  However  is there a way to tell if two objects are equal  much like the hash code value in Java   Stack Overflow question Is there any kind of hashCode function in JavaScript  is similar to this question  but requires a more academic answer  The scenario above demonstrates why it would be necessary to have one  and I m wondering if there is any equivalent solution

User · Answer

This is an addition for all the above  not a replacement  If you need to fast shallow-compare objects without need to check extra recursive cases  Here is a shot   This compares for  1  Equality of number of own properties  2  Equality of key names  3  if bCompareValues    true  Equality of corresponding property values and their types  triple equality   var shallowCompareObjects   function o1  o2  bCompareValues        var s           n1   0          n2   0          b    true       for  s in o1    n1           for  s in o2             if   o1 hasOwnProperty s                 b   false              break                    if  bCompareValues  amp  amp  o1 s      o2 s                 b   false              break                    n2               return b  amp  amp  n1    n2

User · Answer

If you are using a JSON library  you can encode each object as JSON  then compare the resulting strings for equality   var obj1  test  value    var obj2  test  value2     alert JSON encode obj1    JSON encode obj2      NOTE  While this answer will work in many cases  as several people have pointed out in the comments it s problematic for a variety of reasons  In pretty much all cases you ll want to find a more robust solution

User · Answer

Depends on what you mean by equality  And therefore it is up to you  as the developer of the classes  to define their equality   There s one case used sometimes  where two instances are considered  equal  if they point to the same location in memory  but that is not always what you want  For instance  if I have a Person class  I might want to consider two Person objects  equal  if they have the same Last Name  First Name  and Social Security Number  even if they point to different locations in memory    On the other hand  we can t simply say that two objects are equal if the value of each of their members is the same  since  sometimes  you don t want that  In other words  for each class  it s up to the class developer to define what members make up the objects  identity  and develop a proper equality operator  be it via overloading the    operator or an Equals method    Saying that two objects are equal if they have the same hash is one way out  However you then have to wonder how the hash is calculated for each instance  Going back to the Person example above  we could use this system if the hash was calculated by looking at the values of the First Name  Last Name  and Social Security Number fields  On top of that  we are then relying on the quality of the hashing method  that s a huge topic on its own  but suffice it to say that not all hashes are created equal  and bad hashing methods can lead to more collisions  which in this case would return false matches

User · Answer

Sure  while we re at it I ll throw in my own reinvention of the wheel  I m proud of the number of spokes and materials used                                                                                       var equals   function   objectA  objectB         var result   false          keysA          keysB          Check if they are pointing at the same variable  If they are  no need to test further      if   objectA     objectB             return true                Check if they are the same type  If they are not  no need to test further      if   typeof objectA     typeof objectB             return false                Check what kind of variables they are to see what sort of comparison we should make      if   typeof objectA      object                 Check if they have the same constructor  so that we are comparing apples with apples          if   objectA constructor     objectA constructor                    If we are working with Arrays                if   objectA instanceof Array                        Check the arrays are the same length  If not  they cannot be the same                  if   objectA length     objectB length                            Compare each element  They must be identical  If not  the comparison stops immediately and returns false                      return objectA every                          function   element  i                                 return equals  element  objectB  i                                                                                            They are not the same length  and so are not identical                  else                       return false                                                 If we are working with RegExps                else if   objectA instanceof RegExp                        Return the results of a string comparison of the expression                  return   objectA toString       objectB toString                                   Else we are working with other types of objects                else                      Get the keys as arrays from both objects  This uses Object keys  so no old browsers here                  keysA   Object keys  objectA                     keysB   Object keys  objectB                        Check the key arrays are the same length  If not  they cannot be the same                  if   keysA length     keysB length                            Compare each property  They must be identical  If not  the comparison stops immediately and returns false                      return keysA every                          function   element                                 return equals  objectA  element    objectB  element                                                                                            They do not have the same number of keys  and so are not identical                  else                       return false                                                       They don t have the same constructor          else               return false                         If they are both functions  let us do a string comparison      else if   typeof objectA      function              return   objectA toString       objectB toString                   If a simple variable type  compare directly without coercion      else           return   objectA     objectB                  Return a default if nothing has already been returned      return result                                                                                         It returns false as quickly as possible  but of course for a large object where the difference is deeply nested it could be less effective  In my own scenario  good handling of nested arrays is important   Hope it helps someone needing this kind of  wheel

User · Answer

I ve implemented a method that takes two jsons and checks to see if their keys have the same values using recursion   I used another question to solve this    x000D   x000D  const arraysEqual    a  b    gt    x000D      if  a     b  x000D          return true  x000D      if  a     null    b     null  x000D          return false  x000D      if  a length     b length  x000D          return false  x000D   x000D         If you don t care about the order of the elements inside x000D         the array  you should sort both arrays here  x000D   x000D      for  let i   0  i  lt  a length    i    x000D          if  a i      b i   x000D              return false  x000D        x000D      return true  x000D     x000D   x000D  const jsonsEqual    a  b    gt    x000D   x000D    if typeof a      object     typeof b      object   x000D        return false  x000D   x000D    if  Object keys a  length     Object keys b  length       if items have the same size x000D        let response   true  x000D   x000D        for  let key in a    x000D            if   b key      if not key x000D                response   false  x000D            if  typeof a key      typeof b key      if typeof doesn t equals x000D                response   false  x000D            else   x000D                if  Array isArray a key       if array x000D                    response   arraysEqual a key   b key    x000D                else if  typeof a key       object      if another json x000D                    response   jsonsEqual a key   b key    x000D                else if  a key      b key       not equals x000D                    response   false  x000D              x000D            if   response     return if one item isn t equal x000D                return false  x000D          x000D      else x000D        return false  x000D   x000D    return true  x000D     x000D   x000D  const json1      x000D    a   a    x000D    b   asd    x000D    c    x000D       1   x000D      2  x000D      2 5  x000D       3    x000D        x000D        d   asd   x000D        e    x000D          1 6  x000D             x000D            f   asdasd   x000D            g   123  x000D            x000D          x000D        x000D       x000D    h  1  x000D    i  1 2  x000D     x000D   x000D  const json2     x000D    a   nops   x000D    b   asd  x000D     x000D   x000D  const json3      x000D    a   h    x000D    b   484    x000D    c    x000D      3  x000D      4 5  x000D       2ss    x000D        x000D        e    x000D             x000D            f   asdasd   x000D            g   123  x000D            x000D          x000D        x000D       x000D    h  1  x000D    i  1 2  x000D     x000D   x000D  const result   jsonsEqual json1 json2   x000D    const result   jsonsEqual json1 json3   x000D    const result   jsonsEqual json1 json1   x000D   x000D  if result     is equal x000D        result   text  Jsons are the same   x000D  else x000D        result   text  Jsons aren t equals   x000D   lt script src  https   ajax googleapis com ajax libs jquery 2 1 1 jquery min js  gt  lt  script gt  x000D   x000D   lt div id  result  gt  lt  div gt  x000D   x000D   x000D

User · Answer

you can use   isEqual obj1  obj2  from the underscore js library   Here is an example   var stooge    name   moe   luckyNumbers   13  27  34    var clone     name   moe   luckyNumbers   13  27  34    stooge    clone    gt  false   isEqual stooge  clone     gt  true   See the official documentation from here  http   underscorejs org  isEqual

User · Answer

Needing a more generic object comparison function than had been posted  I cooked up the following  Critique appreciated     Object prototype equals   function iObj      if  this constructor     iObj constructor      return false    var aMemberCount   0    for  var a in this        if   this hasOwnProperty a         continue      if  typeof this a       object   amp  amp  typeof iObj a       object     this a  equals iObj a     this a      iObj a         return false        aMemberCount        for  var a in iObj      if  iObj hasOwnProperty a         --aMemberCount    return aMemberCount   false   true

User · Answer

Why reinvent the wheel  Give Lodash a try  It has a number of must-have functions such as isEqual       isEqual object  other     It will brute force check each key value - just like the other examples on this page - using ECMAScript nbsp 5 and native optimizations if they re available in the browser   Note  Previously this answer recommended Underscore js  but lodash has done a better job of getting bugs fixed and addressing issues with consistency

User · Answer

Here is a very basic approach to checking an object s  value equality    var john         occupation   Web Developer       age  25     var bobby         occupation   Web Developer       age  25     function isEquivalent a  b           Create arrays of property names      var aProps   Object getOwnPropertyNames a       var bProps   Object getOwnPropertyNames b           If number of properties is different  objects are not equivalent      if  aProps length    bProps length            return false             for  var i   0  i  lt  aProps length  i              var propName   aProps i               If values of same property are not equal  objects are not equivalent         if  a propName      b propName                return false                          If we made it this far  objects are considered equivalent     return true        Outputs  true console log isEquivalent john  bobby      Demo - JSFiddle  As you can see  to check the objects   value equality  we essentially have to iterate over every property in the objects to see whether they are equal  And while this simple implementation works for our example  there are a lot of cases that it doesn t handle  For instance    What if one of the property values is itself an object  What if one of the property values is NaN  the only value in JavaScript that is not equal to itself   What if a has a property with value undefined  while b doesn t have this property  which thus evaluates to undefined     For a robust method of checking objects   value equality  it is better to rely on a well-tested library that covers the various edge cases like Underscore    var john         occupation   Web Developer       age  25     var bobby         occupation   Web Developer       age  25        Outputs  true console log   isEqual john  bobby      Demo - JSFiddle

User · Answer

function isEqual obj1  obj2       type1   typeof obj1       type2   typeof obj2       if type1   type2           switch  type1               case  object   return JSON stringify obj1    JSON stringify obj2               case  function   return eval obj1  toString     eval obj2  toString                default  return obj1  obj2                      return false     have not tried but should work

User · Answer

This is a classic javascript question  I created a method to check deep object equality with the feature of being able to select properties to ignore from comparison   Arguments are the two objects to compare  plus  an optional array of stringified property-to-ignore relative path   function isObjectEqual  o1  o2  ignorePropsArr              Deep Clone objects     let  obj1   JSON parse JSON stringify o1             obj2   JSON parse JSON stringify o2           Remove props to ignore     ignorePropsArr map  p   gt             eval   obj1   p      obj2   p      IGNORED                    compare as strings     let s1   JSON stringify  obj1           s2   JSON stringify  obj2          return  s1  s2 s1 s2       return s1  s2        Objects 0 and 1 are exact equals obj0     price  66544 10  RSIs   0 000432334  0 00046531   candles   A  543  B  321  C  4322   obj1     price  66544 10  RSIs   0 000432334  0 00046531   candles   A  543  B  321  C  4322   obj2     price  66544 12  RSIs   0 000432334  0 00046531   candles   A  543  B  321  C  4322   obj3     price  66544 13  RSIs   0 000432334  0 00046531   candles   A  541  B  321  C  4322   obj4     price  66544 14  RSIs   0 000432334  0 00046530   candles   A  543  B  321  C  4322    isObjectEqual obj0 obj1     true isObjectEqual obj0 obj2     false isObjectEqual obj0 obj2   price       true isObjectEqual obj0 obj3   price       false isObjectEqual obj0 obj3   price   candles A       true isObjectEqual obj0 obj4   price   RSIs 1          true

User · Answer

I d advise against hashing or serialization  as the JSON solution suggest    If you need to test if two objects are equal  then you need to define what equals means   It could be that all data members in both objects match  or it could be that must the memory locations match  meaning both variables reference the same object in memory   or may be that only one data member in each object must match   Recently I developed an object whose constructor creates a new id  starting from 1 and incrementing by 1  each time an instance is created   This object has an isEqual function that compares that id value with the id value of another object and returns true if they match   In that case I defined  equal  as meaning the the id values match   Given that each instance has a unique id this could be used to enforce the idea that matching objects also occupy the same memory location   Although that is not necessary

User · Answer

Assuming that the order of the properties in the object is not changed   JSON stringify   works for deep and non-deep both types of objects  not very sure of performance aspects    x000D   x000D  var object1     x000D    key   value  x000D     x000D   x000D  var object2     x000D    key   value  x000D     x000D   x000D  var object3     x000D    key   no value  x000D     x000D   x000D  console log  object1 and object2 are equal     JSON stringify object1      JSON stringify object2    x000D   x000D  console log  object2 and object3 are equal     JSON stringify object2      JSON stringify object3    x000D   x000D   x000D

User · Answer

Here is generic equality checker function that receives array of elements as input and compare them to each other  Works with all types of elements     const isEqual   function inputs              Checks an element if js object    const isObject   function data        return Object prototype toString call data        object Object              Sorts given object by its keys    const sortObjectByKey   function obj        const self   this      if   obj  return         return Object keys obj  sort   reduce  initialVal  item    gt          initialVal item     Array isArray obj item    amp  amp          typeof obj item       object            self objectByKey obj item             obj item         return initialVal                         Checks equality of all elements in the input against each other  Returns true   false   return       inputs        map          input   gt            typeof input     undefined                                 isObject input                    JSON stringify sortObjectByKey input                     JSON stringify input                 reduce           prevValue  input    gt            prevValue           prevValue     input   input   false                         false             Tests  Made with Jest test framework   test  String equality check        gt      expect isEqual   murat     toEqual true     expect isEqual   murat    john    doe     toEqual false     expect isEqual   murat    murat    murat     toEqual true        test  Float equality check        gt      expect isEqual  7 89  3 45    toEqual false     expect isEqual  7  7 50    toEqual false     expect isEqual  7 50  7 50    toEqual true     expect isEqual  7  7    toEqual true     expect isEqual  0 34  0 33    toEqual false     expect isEqual  0 33  0 33    toEqual true        test  Array equality check        gt      expect isEqual   1  2  3    1  2  3     toEqual true     expect isEqual   1  3    1  2  3     toEqual false     expect isEqual    murat   18     murat   18     toEqual true        test  Object equality check        gt      let obj1         name   murat       age  18        let obj2         name   murat       age  18        let obj3         age  18      name   murat         let obj4         name   murat       age  18      occupation   nothing         expect isEqual  obj1  obj2    toEqual true     expect isEqual  obj1  obj2  obj3    toEqual true     expect isEqual  obj1  obj2  obj3  obj4    toEqual false        test  Weird equality checks        gt      expect isEqual            toEqual false     expect isEqual  0   0     toEqual false         There is also a gist

User · Answer

How to determine that the partial object  Partial lt T gt   is equal to the original object  T  in typescript   function compareTwoObjects lt T gt  original  T  partial  Partial lt T gt    boolean     return  Object keys partial  some  key    gt  partial key      original key         P S  Initially I was planning to create a new question with an answer  But such a question already exists and marked as a duplicate

User · Answer

x000D   x000D  function isDeepEqual obj1  obj2  testPrototypes   false    x000D    if  obj1     obj2    x000D      return true x000D      x000D   x000D    if  typeof obj1      function   amp  amp  typeof obj2      function     x000D      return obj1 toString       obj2 toString   x000D      x000D   x000D    if  obj1 instanceof Date  amp  amp  obj2 instanceof Date    x000D      return obj1 getTime       obj2 getTime   x000D      x000D   x000D    if   x000D      Object prototype toString call obj1      x000D        Object prototype toString call obj2     x000D      typeof obj1      object  x000D        x000D      return false x000D      x000D   x000D    const prototypesAreEqual   testPrototypes x000D        isDeepEqual  x000D          Object getPrototypeOf obj1   x000D          Object getPrototypeOf obj2   x000D          true x000D          x000D        true x000D   x000D    const obj1Props   Object getOwnPropertyNames obj1  x000D    const obj2Props   Object getOwnPropertyNames obj2  x000D   x000D    return   x000D      obj1Props length     obj2Props length  amp  amp  x000D      prototypesAreEqual  amp  amp  x000D      obj1Props every prop   gt  isDeepEqual obj1 prop   obj2 prop    x000D      x000D    x000D   x000D  console log isDeepEqual  key   one     key   first     x000D  console log isDeepEqual  key   one     key   one     x000D   x000D   x000D

User · Answer

If you are using a JSON library  you can encode each object as JSON  then compare the resulting strings for equality   var obj1  test  value    var obj2  test  value2     alert JSON encode obj1    JSON encode obj2      NOTE  While this answer will work in many cases  as several people have pointed out in the comments it s problematic for a variety of reasons  In pretty much all cases you ll want to find a more robust solution

User · Answer

x000D   x000D  const obj       name   Carl     age  15   const obj2       name   Carl     age  15      const compareObj    objects    gt      const res    objects map  item    gt        return Object entries item  flat   join          return res every  a    gt        return a     res 0          console log compareObj  obj obj2    x000D   x000D   x000D

User · Answer

If you are comparing JSON objects you can use https   github com mirek node-rus-diff  npm install rus-diff   Usage   a    foo  bar 1   b    foo  bar 1   c    foo  bar 2    var rusDiff   require  rus-diff   rusDiff  console log rusDiff a  b      - gt  false  meaning a and b are equal console log rusDiff a  c      - gt      set      foo bar   2       If two objects are different  a MongoDB compatible   rename         unset         set        like object is returned

User · Answer

This question has more than 30 answers already   I am going to summarize and explain them  with a  quot my father quot  analogy  and add my suggested solution  You have 4 1 classes of solutions   1  Use a hacky incomplete quick one-liner Good if you are in a rush and 99  correctness works  Examples of this is  JSON stringify   suggested by Pratik Bhalodiya  or JSON encode by Joel Anair  or  toString    or other methods that transform your objects into a String and then compare the two Strings using     character by character  The drawback  however  is that there is no globally standard unique representation of an Object in String   e g    a  5  b  8  and  b  8 and a  5   are equal   Pros  Fast  quick  Cons  Hopefully works   It will not work if the environment browser engine memorizes the ordering for objects  e g  Chrome V8  and the order of the keys are different  Thanks to Eksapsy   So  not guaranteed at all   Performance wouldn t be great either in large objects   My Father Analogy When I am talking about my father   quot my tall handsome father quot  and  quot my handsome tall father quot  are the same person   But the two strings are not the same  Note that there is actually a correct  standard way  order of adjectives in English grammar  which says it should be a  quot handsome tall man  quot  but you are risking your competency if you blindly assume Javascript engine of iOS 8 Safari is also abiding the same grammar  blindly   WelcomeToJavascriptNonStandards  2  Write your own DIY recursive function Good if you are learning  Examples are atmin s solution  The biggest disadvantage is you will definitely miss some edge cases   Have you considered a self-reference in object values   Have you considered NaN  Have you considered two objects that have the same ownProperties but different prototypical parents  I would only encourage people to do this if they are practicing and the code is not going to go in production   That s the only case that reinventing the wheel has justifications   Pros  Learning opportunity  Cons  Not reliable   Takes time and concerns   My Father Analogy It s like assuming if my dad s name is  quot John Smith quot  and his birthday is  quot 1 1 1970 quot   then anyone whose name is  quot John Smith quot  and is born on  quot 1 1 1970 quot  is my father  That s usually the case  but what if there are two  quot John Smith quot s born on that day   If you think you will consider their height  then that s increasing the accuracy but still not a perfect comparison  2 1 You limited scope DIY comparator Rather than going on a wild chase of checking all the properties recursively  one might consider checking only  quot a limited quot  number of properties   For instance  if the objects are Users  you can compare their emailAddress field  It s still not a perfect one  but the benefits over solution  2 are   It s predictable  and it s less likely to crash  You are driving the  quot definition quot  of equality  rather than relying on a wild form and shape of the Object and its prototype and nested properties    3  Use a library version of equal function Good if you need a production-level quality  and you cannot change the design of the system  Examples are   equal of lodash  already in coolaj86 s answer or Angular s or Ember s as mentioned in Tony Harvey s answer or Node s by Rafael Xavier   Pros  It s what everyone else does  Cons  External dependency  which can cost you extra memory CPU Security concerns  even a little bit   Also  can still miss some edge cases  e g  whether two objects having same ownProperties but different prototypical parents should be considered the same or not   Finally  you might be unintentionally band-aiding an underlying design problem with this  just saying   My Father Analogy It s like paying an agency to find my biological father  based on his phone  name  address  etc  It s gonna cost more  and it s probably more accurate than myself running the background check  but doesn t cover edge cases like when my father is immigrant asylum and his birthday is unknown   4  Use an IDentifier in the Object Good if you  still  can change the design of the system  objects you are dealing with  and you want your code to last long  It s not applicable in all cases  and might not be very performant   However  it s a very reliable solution  if you can make it  The solution is  every object in the system will have a unique identifier along with all the other properties   The uniqueness of the identifier will be guaranteed at the time of generation   And you will use this ID  also known as UUID GUID -- Globally Universally Unique Identifier  when it comes to comparing two objects   i e  They are equal if and only if these IDs are equal  The IDs can be simple auto incremental numbers  or a string generated via a library  advised  or a piece of code   All you need to do is make sure it s always unique  which in case of auto incremental it can be built-in  or in case of UUID  can be checked will all existing values  e g  MySQL s UNIQUE column attribute  or simply  if coming from a library  be relied upon giving the extremely low likelihood of a collision  Note that you also need to store the ID with the object at all times  to guarantee its uniqueness   and computing it in real-time might not be the best approach   Pros  Reliable  efficient  not dirty  modern  Cons  Needs extra space   Might need a redesign of the system   My Father Analogy It s like known my father s Social Security Number is 911-345-9283  so anyone who has this SSN is my father  and anyone who claims to be my father must have this SSN   Conclusion I personally prefer solution  4  ID  over them all for accuracy and reliability   If it s not possible I d go with  2 1 for predictability  and then  3   If neither is possible   2 and finally  1

User · Answer

x000D   x000D  function isDeepEqual obj1  obj2  testPrototypes   false    x000D    if  obj1     obj2    x000D      return true x000D      x000D   x000D    if  typeof obj1      function   amp  amp  typeof obj2      function     x000D      return obj1 toString       obj2 toString   x000D      x000D   x000D    if  obj1 instanceof Date  amp  amp  obj2 instanceof Date    x000D      return obj1 getTime       obj2 getTime   x000D      x000D   x000D    if   x000D      Object prototype toString call obj1      x000D        Object prototype toString call obj2     x000D      typeof obj1      object  x000D        x000D      return false x000D      x000D   x000D    const prototypesAreEqual   testPrototypes x000D        isDeepEqual  x000D          Object getPrototypeOf obj1   x000D          Object getPrototypeOf obj2   x000D          true x000D          x000D        true x000D   x000D    const obj1Props   Object getOwnPropertyNames obj1  x000D    const obj2Props   Object getOwnPropertyNames obj2  x000D   x000D    return   x000D      obj1Props length     obj2Props length  amp  amp  x000D      prototypesAreEqual  amp  amp  x000D      obj1Props every prop   gt  isDeepEqual obj1 prop   obj2 prop    x000D      x000D    x000D   x000D  console log isDeepEqual  key   one     key   first     x000D  console log isDeepEqual  key   one     key   one     x000D   x000D   x000D

User · Answer

I d advise against hashing or serialization  as the JSON solution suggest    If you need to test if two objects are equal  then you need to define what equals means   It could be that all data members in both objects match  or it could be that must the memory locations match  meaning both variables reference the same object in memory   or may be that only one data member in each object must match   Recently I developed an object whose constructor creates a new id  starting from 1 and incrementing by 1  each time an instance is created   This object has an isEqual function that compares that id value with the id value of another object and returns true if they match   In that case I defined  equal  as meaning the the id values match   Given that each instance has a unique id this could be used to enforce the idea that matching objects also occupy the same memory location   Although that is not necessary

User · Answer

Here s a pretty clean CoffeeScript version of how you could do this   Object  equals    other  - gt    typeOf   Object  toString    return false if typeOf call this  isnt typeOf call other    return  this    other  unless typeOf call other  is   object Object   or                                 typeOf call other  is   object Array       return false unless this key  equals other key   for key  value of this    return false if typeof this key  is  undefined   for key of other    true   Here are the tests     describe  equals   - gt       it  should consider two numbers to be equal   - gt        assert 5 equals 5       it  should consider two empty objects to be equal   - gt        assert    equals          it  should consider two objects with one key to be equal   - gt        assert  a   banana   equals  a   banana        it  should consider two objects with keys in different orders to be equal   - gt        assert  a   banana   kendall   garrus   equals  kendall   garrus   a   banana        it  should consider two objects with nested objects to be equal   - gt        assert  a   fruit   banana    equals  a   fruit   banana         it  should consider two objects with nested objects that are jumbled to be equal   - gt        assert  a   a   banana   kendall   garrus    equals  a   kendall   garrus   a   banana         it  should consider two objects with arrays as values to be equal   - gt        assert  a    apple    banana    equals  a    apple    banana           it  should not consider an object to be equal to null   - gt        assert    a   banana   equals null       it  should not consider two objects with different keys to be equal   - gt        assert    a   banana   equals          it  should not consider two objects with different values to be equal   - gt        assert    a   banana   equals  a   grapefruit

User · Answer

Heres s a solution in ES6 ES2015 using a functional-style approach   const typeOf   x   gt          toString        call x         match    object   w       1   function areSimilar a  b      const everyKey   f   gt  Object keys a  every f     switch typeOf a         case  Array         return a length     b length  amp  amp          everyKey k   gt  areSimilar a sort   k   b sort   k         case  Object         return Object keys a  length     Object keys b  length  amp  amp          everyKey k   gt  areSimilar a k   b k         default        return a     b          demo available here

User · Answer

Here is a very basic approach to checking an object s  value equality    var john         occupation   Web Developer       age  25     var bobby         occupation   Web Developer       age  25     function isEquivalent a  b           Create arrays of property names      var aProps   Object getOwnPropertyNames a       var bProps   Object getOwnPropertyNames b           If number of properties is different  objects are not equivalent      if  aProps length    bProps length            return false             for  var i   0  i  lt  aProps length  i              var propName   aProps i               If values of same property are not equal  objects are not equivalent         if  a propName      b propName                return false                          If we made it this far  objects are considered equivalent     return true        Outputs  true console log isEquivalent john  bobby      Demo - JSFiddle  As you can see  to check the objects   value equality  we essentially have to iterate over every property in the objects to see whether they are equal  And while this simple implementation works for our example  there are a lot of cases that it doesn t handle  For instance    What if one of the property values is itself an object  What if one of the property values is NaN  the only value in JavaScript that is not equal to itself   What if a has a property with value undefined  while b doesn t have this property  which thus evaluates to undefined     For a robust method of checking objects   value equality  it is better to rely on a well-tested library that covers the various edge cases like Underscore    var john         occupation   Web Developer       age  25     var bobby         occupation   Web Developer       age  25        Outputs  true console log   isEqual john  bobby      Demo - JSFiddle

User · Answer

This is a classic javascript question  I created a method to check deep object equality with the feature of being able to select properties to ignore from comparison   Arguments are the two objects to compare  plus  an optional array of stringified property-to-ignore relative path   function isObjectEqual  o1  o2  ignorePropsArr              Deep Clone objects     let  obj1   JSON parse JSON stringify o1             obj2   JSON parse JSON stringify o2           Remove props to ignore     ignorePropsArr map  p   gt             eval   obj1   p      obj2   p      IGNORED                    compare as strings     let s1   JSON stringify  obj1           s2   JSON stringify  obj2          return  s1  s2 s1 s2       return s1  s2        Objects 0 and 1 are exact equals obj0     price  66544 10  RSIs   0 000432334  0 00046531   candles   A  543  B  321  C  4322   obj1     price  66544 10  RSIs   0 000432334  0 00046531   candles   A  543  B  321  C  4322   obj2     price  66544 12  RSIs   0 000432334  0 00046531   candles   A  543  B  321  C  4322   obj3     price  66544 13  RSIs   0 000432334  0 00046531   candles   A  541  B  321  C  4322   obj4     price  66544 14  RSIs   0 000432334  0 00046530   candles   A  543  B  321  C  4322    isObjectEqual obj0 obj1     true isObjectEqual obj0 obj2     false isObjectEqual obj0 obj2   price       true isObjectEqual obj0 obj3   price       false isObjectEqual obj0 obj3   price   candles A       true isObjectEqual obj0 obj4   price   RSIs 1          true

User · Answer

Here s a version of the stringify trick that is less typing and works in a lot of cases for trivial JSON data comparisons    var obj1Fingerprint   JSON stringify obj1  replace        g     split      sort   join       var obj2Fingerprint   JSON stringify obj2  replace        g     split      sort   join       if   obj1Fingerprint     obj2Fingerprint          else

User · Answer

This is a simple Javascript function to compare two objects having simple key-value pairs  The function will return an array of strings  where each string is a path to an inequality between the two objects   function compare a b        var paths               new Set Object keys a  concat Object keys b     forEach key  gt           if typeof a key       object   amp  amp  typeof b key       object                 var results   compare a key   b key                if JSON stringify results                            paths push    results map result  gt key concat    gt   result                                     else if  a key    b key                 paths push key                        return paths      If you only want to compare two objects without knowing the paths to inequalities  you can do it as follows   if JSON stringify compare object1  object2                   the two objects are equal   else         the two objects are not equal

User · Answer

Needing a more generic object comparison function than had been posted  I cooked up the following  Critique appreciated     Object prototype equals   function iObj      if  this constructor     iObj constructor      return false    var aMemberCount   0    for  var a in this        if   this hasOwnProperty a         continue      if  typeof this a       object   amp  amp  typeof iObj a       object     this a  equals iObj a     this a      iObj a         return false        aMemberCount        for  var a in iObj      if  iObj hasOwnProperty a         --aMemberCount    return aMemberCount   false   true

User · Answer

x000D   x000D       let user1     x000D          name   John   x000D          address    x000D              line1   55 Green Park Road   x000D              line2    x000D                a  1 2 3  x000D                 x000D             x000D          email null x000D            x000D       x000D       let user2     x000D          name   John   x000D          address    x000D              line1   55 Green Park Road   x000D              line2    x000D                a  1 2 3  x000D                 x000D             x000D          email null x000D             x000D       x000D         Method 1 x000D       x000D      function isEqual a  b    x000D            return JSON stringify a      JSON stringify b   x000D        x000D       x000D         Method 2 x000D       x000D      function isEqual a  b    x000D           checking type of a And b x000D        if typeof a      object     typeof b      object     x000D          return false  x000D          x000D         x000D           Both are NULL x000D        if  a  amp  amp   b     x000D           return true  x000D          else if  a     b    x000D           return false  x000D          x000D         x000D        let keysA   Object keys a   x000D        let keysB   Object keys b   x000D        if keysA length     keysB length    x000D          return false  x000D          x000D        for let key in a    x000D         if   key in b     x000D           return false  x000D           x000D           x000D         if typeof a key       object     x000D           if  isEqual a key   b key    x000D               x000D               return false  x000D               x000D           else   x000D           if a key      b key     x000D             return false  x000D             x000D           x000D          x000D         x000D        return true  x000D        x000D   x000D   x000D   x000D  console log isEqual user1 user2    x000D   x000D   x000D

User · Answer

How to determine that the partial object  Partial lt T gt   is equal to the original object  T  in typescript   function compareTwoObjects lt T gt  original  T  partial  Partial lt T gt    boolean     return  Object keys partial  some  key    gt  partial key      original key         P S  Initially I was planning to create a new question with an answer  But such a question already exists and marked as a duplicate

User · Answer

Though there are so many answers to this question already  My attempt is just to provide one more way of implementing this    x000D   x000D  const primitveDataTypes     number    boolean    string    undefined    x000D  const isDateOrRegExp    value    gt  value instanceof Date    value instanceof RegExp  x000D  const compare    first  second    gt    x000D      let agg   true  x000D      if typeof first     typeof second  amp  amp  primitveDataTypes indexOf typeof first      -1  amp  amp  first     second   x000D          agg    false  x000D        x000D         adding support for Date and RegExp  x000D      else if isDateOrRegExp first     isDateOrRegExp second    x000D          if first toString       second toString     x000D              agg   false  x000D            x000D        x000D      else   x000D          if Array isArray first   amp  amp  Array isArray second    x000D          if first length     second length   x000D               for let i   0  i  lt  first length  i     x000D                  if typeof first i       object   amp  amp  typeof second i       object    x000D                      agg   compare first i   second i    x000D                    x000D                  else if first i      second i    x000D                      agg   false  x000D                    x000D                x000D            else   x000D              agg   false  x000D            x000D        else   x000D          const firstKeys   Object keys first   x000D          const secondKeys   Object keys second   x000D          if firstKeys length     secondKeys length   x000D              agg   false  x000D            x000D          for let j   0   j  lt  firstKeys length  j     x000D              if firstKeys j      secondKeys j    x000D                  agg   false  x000D                x000D              if first firstKeys j    amp  amp  second secondKeys j    amp  amp  typeof first firstKeys j        object   amp  amp  typeof second secondKeys j        object    x000D                  agg   compare first firstKeys j    second secondKeys j     x000D                  x000D               else if first firstKeys j       second secondKeys j     x000D                  agg   false  x000D                  x000D            x000D        x000D        x000D      return agg  x000D    x000D   x000D   x000D  console log  result   compare  a  1  b    c   4   d 5    e 6     r  null    a  1  b    c   4   d 5    e 6     r   ffd         returns false  x000D   x000D   x000D

User · Answer

This is my version  It is using new Object keys feature that is introduced in ES5 and ideas tests from      and      x000D   x000D  function objectEquals x  y    x000D       use strict   x000D   x000D      if  x     null    x     undefined    y     null    y     undefined    return x     y    x000D         after this just checking type of one would be enough x000D      if  x constructor     y constructor    return false    x000D         if they are functions  they should exactly refer to same one  because of closures  x000D      if  x instanceof Function    return x     y    x000D         if they are regexps  they should exactly refer to same one  it is hard to better equality check on current ES  x000D      if  x instanceof RegExp    return x     y    x000D      if  x     y    x valueOf       y valueOf      return true    x000D      if  Array isArray x   amp  amp  x length     y length    return false    x000D   x000D         if they are dates  they must had equal valueOf x000D      if  x instanceof Date    return false    x000D   x000D         if they are strictly equal  they both need to be object at least x000D      if    x instanceof Object     return false    x000D      if    y instanceof Object     return false    x000D   x000D         recursive object equality check x000D      var p   Object keys x   x000D      return Object keys y  every function  i    return p indexOf i      -1      amp  amp  x000D          p every function  i    return objectEquals x i   y i        x000D    x000D   x000D   x000D                                                                  x000D      The borrowed tests  run them by clicking  Run code snippet  x000D                                                                  x000D  var printResult   function  x    x000D      if  x    document write   lt div style  color  green   gt Passed lt  div gt       x000D      else   document write   lt div style  color  red   gt Failed lt  div gt       x000D     x000D  var assert     isTrue  function  x    printResult x      isFalse  function  x    printResult  x       x000D  assert isTrue objectEquals null null    x000D  assert isFalse objectEquals null undefined    x000D  assert isFalse objectEquals  abc    abc     x000D  assert isFalse objectEquals  abc    123     x000D  var r    abc   x000D  assert isTrue objectEquals r  r    x000D   x000D  assert isTrue objectEquals  hi   hi     x000D  assert isTrue objectEquals 5 5    x000D  assert isFalse objectEquals 5 10    x000D   x000D  assert isTrue objectEquals          x000D  assert isTrue objectEquals  1 2   1 2     x000D  assert isFalse objectEquals  1 2   2 1     x000D  assert isFalse objectEquals  1 2   1 2 3     x000D   x000D  assert isTrue objectEquals          x000D  assert isTrue objectEquals  a 1 b 2   a 1 b 2     x000D  assert isTrue objectEquals  a 1 b 2   b 2 a 1     x000D  assert isFalse objectEquals  a 1 b 2   a 1 b 3     x000D   x000D  assert isTrue objectEquals  1  name  mhc  age 28   2  name  arb  age 26    1  name  mhc  age 28   2  name  arb  age 26      x000D  assert isFalse objectEquals  1  name  mhc  age 28   2  name  arb  age 26    1  name  mhc  age 28   2  name  arb  age 27      x000D   x000D  Object prototype equals   function  obj    return objectEquals this  obj      x000D  var assertFalse   assert isFalse  x000D      assertTrue   assert isTrue  x000D   x000D  assertFalse    equals null    x000D  assertFalse    equals undefined    x000D   x000D  assertTrue  hi  equals  hi     x000D  assertTrue new Number 5  equals 5    x000D  assertFalse new Number 5  equals 10    x000D  assertFalse new Number 1  equals  1     x000D   x000D  assertTrue    equals       x000D  assertTrue  1 2  equals  1 2     x000D  assertFalse  1 2  equals  2 1     x000D  assertFalse  1 2  equals  1 2 3     x000D  assertTrue new Date  2011-03-31   equals new Date  2011-03-31      x000D  assertFalse new Date  2011-03-31   equals new Date  1970-01-01      x000D   x000D  assertTrue    equals       x000D  assertTrue  a 1 b 2  equals  a 1 b 2     x000D  assertTrue  a 1 b 2  equals  b 2 a 1     x000D  assertFalse  a 1 b 2  equals  a 1 b 3     x000D   x000D  assertTrue  1  name  mhc  age 28   2  name  arb  age 26   equals  1  name  mhc  age 28   2  name  arb  age 26      x000D  assertFalse  1  name  mhc  age 28   2  name  arb  age 26   equals  1  name  mhc  age 28   2  name  arb  age 27      x000D   x000D  var a    a   text   b  0 1    x000D  var b    a   text   b  0 1    x000D  var c    a   text   b  0   x000D  var d    a   text   b  false   x000D  var e    a   text   b  1 0    x000D  var i     x000D      a   text   x000D      c    x000D          b   1  0  x000D        x000D     x000D  var j     x000D      a   text   x000D      c    x000D          b   1  0  x000D        x000D     x000D  var k    a   text   b  null   x000D  var l    a   text   b  undefined   x000D   x000D  assertTrue a equals b    x000D  assertFalse a equals c    x000D  assertFalse c equals d    x000D  assertFalse a equals e    x000D  assertTrue i equals j    x000D  assertFalse d equals k    x000D  assertFalse k equals l    x000D   x000D     from comments on stackoverflow post x000D  assert isFalse objectEquals  1  2  undefined    1  2     x000D  assert isFalse objectEquals  1  2  3     0  1  1  2  2  3      x000D  assert isFalse objectEquals new Date 1234   1234    x000D   x000D     no two different function is equal really  they capture their context variables x000D     so even if they have same toString    they won t have same functionality x000D  var func   function  x    return true     x000D  var func2   function  x    return true     x000D  assert isTrue objectEquals func  func    x000D  assert isFalse objectEquals func  func2    x000D  assert isTrue objectEquals   a    b  func        a    b  func        x000D  assert isFalse objectEquals   a    b  func        a    b  func2        x000D   x000D   x000D

User · Answer

Simplest and logical solutions for comparing everything Like Object  Array  String  Int     JSON stringify  a  val1       JSON stringify  a  val2    Note     you need to replace val1and val2 with your Object for the object  you have to sort by key  recursively for both side objects

User · Answer

Depending  If the order of keys in the object are not of importance  and I don t need to know the prototypes of the said object  Using always do the job   const object       JSON stringify object           will pass but             will not

User · Answer

Here s a version of the stringify trick that is less typing and works in a lot of cases for trivial JSON data comparisons    var obj1Fingerprint   JSON stringify obj1  replace        g     split      sort   join       var obj2Fingerprint   JSON stringify obj2  replace        g     split      sort   join       if   obj1Fingerprint     obj2Fingerprint          else

User · Answer

It s useful to consider two objects equal if they have all the same values for all properties and recursively for all nested objects and arrays   I also consider the following two objects equal   var a    p1  1   var b    p1  1  p2  undefined     Similarly  arrays can have  missing  elements and undefined elements   I would treat those the same as well   var c    1  2   var d    1  2  undefined     A function that implements this definition of equality   function isEqual a  b        if  a     b            return true             if  generalType a     generalType b             return false             if  a    b            return true             if  typeof a     object             return false                null           if  a instanceof Object    b instanceof Object            return false             if  a instanceof Date    b instanceof Date            if  a instanceof Date    b instanceof Date                a getTime      b getTime                  return false                       var allKeys      concat keys a   keys b        uniqueArray allKeys        for  var i   0  i  lt  allKeys length  i              var prop   allKeys i           if   isEqual a prop   b prop                  return false                      return true      Source code  including the helper functions  generalType and uniqueArray   Unit Test and Test Runner here

User · Answer

Are you trying to test if two objects are the equal  ie  their properties are equal   If this is the case  you ll probably have noticed this situation   var a     foo    bar     var b     foo    bar     alert  a    b    Equal     Not equal        Not equal    you might have to do something like this   function objectEquals obj1  obj2        for  var i in obj1            if  obj1 hasOwnProperty i                 if   obj2 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      for  var i in obj2            if  obj2 hasOwnProperty i                 if   obj1 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      return true      Obviously that function could do with quite a bit of optimisation  and the ability to do deep checking  to handle nested objects  var a     foo     fu    bar       but you get the idea   As FOR pointed out  you might have to adapt this for your own purposes  eg  different classes may have different definitions of  equal   If you re just working with plain objects  the above may suffice  otherwise a custom MyClass equals   function may be the way to go

User · Answer

I have a much shorter function that will go deep into all sub objects or arrays  It is as efficient as JSON stringify obj1      JSON stringify obj2  but JSON stringify will not work if the order is not the same  as mentioned here    var obj1     a   1  b   2    var obj2     b   2  a   1     console log JSON stringify obj1      JSON stringify obj2       false   The function would also be a good start if you want to do something with the unequal values    x000D   x000D  function arr or obj v  x000D    return   v  amp  amp   v constructor     Object    v constructor     Array     x000D   x000D  function deep equal v1  v2  x000D    x000D      if  arr or obj v1   amp  amp  arr or obj v2   amp  amp  v1 constructor     v2 constructor  x000D        x000D          if  Object keys v1  length     Object keys v2  length     check the length x000D          for  var i in v1  x000D            x000D              if   deep equal v1 i   v2 i    x000D                return false    x000D            x000D          else x000D            return false    x000D        x000D      else if  v1     v2  x000D        return false    x000D   x000D      return true  x000D    x000D   x000D                                                                     x000D                                                                     x000D   x000D  var obj1     x000D        x000D          hat     x000D              cap     something   null    x000D              helmet      triple eight    pro-tec    x000D             x000D          shoes      loafer    penny    x000D         x000D        x000D          beers      budweiser    busch     x000D          wines      barefoot    yellow tail    x000D        x000D     x000D   x000D  var obj2     x000D        x000D          shoes      loafer    penny        same even if the order is different x000D          hat     x000D              cap     something   null    x000D              helmet      triple eight    pro-tec    x000D            x000D         x000D        x000D          beers      budweiser    busch     x000D          wines      barefoot    yellow tail    x000D        x000D     x000D   x000D  console log deep equal obj1  obj2       true x000D  console log JSON stringify obj1      JSON stringify obj2       false x000D  console log deep equal              true x000D  console log deep equal              true x000D  console log deep equal              false x000D   x000D   x000D    And if you want to add support for Function  Date and RegExp  you can add this at the beginning of deep equal  not tested    if   typeof obj1      function   amp  amp  typeof obj2      function       obj1 instanceof Date  amp  amp  obj2 instanceof Date      obj1 instanceof RegExp  amp  amp  obj2 instanceof RegExp         obj1   obj1 toString        obj2   obj2 toString

User · Answer

sort the objects  dictionary  compare JSON string  function areTwoDictsEqual dictA  dictB        function sortDict dict            var keys   Object keys dict           keys sort             var newDict               for  var i 0  i lt keys length  i                  var key   keys i               var value   dict key               newDict key    value                     return newDict             return JSON stringify sortDict dictA      JSON stringify sortDict dictB

User · Answer

Here is generic equality checker function that receives array of elements as input and compare them to each other  Works with all types of elements     const isEqual   function inputs              Checks an element if js object    const isObject   function data        return Object prototype toString call data        object Object              Sorts given object by its keys    const sortObjectByKey   function obj        const self   this      if   obj  return         return Object keys obj  sort   reduce  initialVal  item    gt          initialVal item     Array isArray obj item    amp  amp          typeof obj item       object            self objectByKey obj item             obj item         return initialVal                         Checks equality of all elements in the input against each other  Returns true   false   return       inputs        map          input   gt            typeof input     undefined                                 isObject input                    JSON stringify sortObjectByKey input                     JSON stringify input                 reduce           prevValue  input    gt            prevValue           prevValue     input   input   false                         false             Tests  Made with Jest test framework   test  String equality check        gt      expect isEqual   murat     toEqual true     expect isEqual   murat    john    doe     toEqual false     expect isEqual   murat    murat    murat     toEqual true        test  Float equality check        gt      expect isEqual  7 89  3 45    toEqual false     expect isEqual  7  7 50    toEqual false     expect isEqual  7 50  7 50    toEqual true     expect isEqual  7  7    toEqual true     expect isEqual  0 34  0 33    toEqual false     expect isEqual  0 33  0 33    toEqual true        test  Array equality check        gt      expect isEqual   1  2  3    1  2  3     toEqual true     expect isEqual   1  3    1  2  3     toEqual false     expect isEqual    murat   18     murat   18     toEqual true        test  Object equality check        gt      let obj1         name   murat       age  18        let obj2         name   murat       age  18        let obj3         age  18      name   murat         let obj4         name   murat       age  18      occupation   nothing         expect isEqual  obj1  obj2    toEqual true     expect isEqual  obj1  obj2  obj3    toEqual true     expect isEqual  obj1  obj2  obj3  obj4    toEqual false        test  Weird equality checks        gt      expect isEqual            toEqual false     expect isEqual  0   0     toEqual false         There is also a gist

User · Answer

My version  which includes the chain of where the difference is found  and what the difference is   function DeepObjectCompare O1  O2        try           DOC Val O1  O2    O1- gt O2   O1  O2            return DOC Val O2  O1    O2- gt O1   O1  O2          catch e            console log e Chain           throw e           function DOC Error Reason  Chain  Val1  Val2        this Reason Reason      this Chain Chain      this Val1 Val1      this Val2 Val2     function DOC Val Val1  Val2  Chain        function DoThrow Reason  NewChain    throw new DOC Error Reason  NewChain   undefined   NewChain   Chain  Val1  Val2           if typeof Val1    typeof Val2           return DoThrow  Type Mismatch        if Val1   null    Val1   undefined          return Val1   Val2   DoThrow  Null undefined mismatch     true      if Val1 constructor   Val2 constructor          return DoThrow  Constructor mismatch        switch typeof Val1                 case  object               for var m in Val1                                if  Val1 hasOwnProperty m                       continue                  var CurChain Chain concat  m                    if  Val2 hasOwnProperty m                       return DoThrow  Val2 missing property   CurChain                   DOC Val Val1 m   Val2 m   CurChain                             return true          case  number               if Number isNaN Val1                   return  Number isNaN Val2    DoThrow  NaN mismatch     true          case  string           case  boolean               return Val1   Val2   DoThrow  Value mismatch     true          case  function               if Val1 prototype   Val2 prototype                  return DoThrow  Prototype mismatch                if Val1   Val2                  return DoThrow  Function mismatch                return true          default              return DoThrow  Val1 is unknown type

User · Answer

For those of you using Node  there is a convenient method called isDeepStrictEqual on the nativeutil library that can achieve this  const util   require  util     const obj1       foo   quot bar quot     baz   1  2      const obj2       foo   quot bar quot     baz   1  2       obj1    obj2    false util isDeepStrictEqual obj1  obj2     true   https   nodejs org api util html util util isdeepstrictequal val1 val2

User · Answer

I ve implemented a method that takes two jsons and checks to see if their keys have the same values using recursion   I used another question to solve this    x000D   x000D  const arraysEqual    a  b    gt    x000D      if  a     b  x000D          return true  x000D      if  a     null    b     null  x000D          return false  x000D      if  a length     b length  x000D          return false  x000D   x000D         If you don t care about the order of the elements inside x000D         the array  you should sort both arrays here  x000D   x000D      for  let i   0  i  lt  a length    i    x000D          if  a i      b i   x000D              return false  x000D        x000D      return true  x000D     x000D   x000D  const jsonsEqual    a  b    gt    x000D   x000D    if typeof a      object     typeof b      object   x000D        return false  x000D   x000D    if  Object keys a  length     Object keys b  length       if items have the same size x000D        let response   true  x000D   x000D        for  let key in a    x000D            if   b key      if not key x000D                response   false  x000D            if  typeof a key      typeof b key      if typeof doesn t equals x000D                response   false  x000D            else   x000D                if  Array isArray a key       if array x000D                    response   arraysEqual a key   b key    x000D                else if  typeof a key       object      if another json x000D                    response   jsonsEqual a key   b key    x000D                else if  a key      b key       not equals x000D                    response   false  x000D              x000D            if   response     return if one item isn t equal x000D                return false  x000D          x000D      else x000D        return false  x000D   x000D    return true  x000D     x000D   x000D  const json1      x000D    a   a    x000D    b   asd    x000D    c    x000D       1   x000D      2  x000D      2 5  x000D       3    x000D        x000D        d   asd   x000D        e    x000D          1 6  x000D             x000D            f   asdasd   x000D            g   123  x000D            x000D          x000D        x000D       x000D    h  1  x000D    i  1 2  x000D     x000D   x000D  const json2     x000D    a   nops   x000D    b   asd  x000D     x000D   x000D  const json3      x000D    a   h    x000D    b   484    x000D    c    x000D      3  x000D      4 5  x000D       2ss    x000D        x000D        e    x000D             x000D            f   asdasd   x000D            g   123  x000D            x000D          x000D        x000D       x000D    h  1  x000D    i  1 2  x000D     x000D   x000D  const result   jsonsEqual json1 json2   x000D    const result   jsonsEqual json1 json3   x000D    const result   jsonsEqual json1 json1   x000D   x000D  if result     is equal x000D        result   text  Jsons are the same   x000D  else x000D        result   text  Jsons aren t equals   x000D   lt script src  https   ajax googleapis com ajax libs jquery 2 1 1 jquery min js  gt  lt  script gt  x000D   x000D   lt div id  result  gt  lt  div gt  x000D   x000D   x000D

User · Answer

Object equality check JSON stringify array1 sort        JSON stringify array2 sort     The above test also works with arrays of objects in which case use a sort function as documented in http   www w3schools com jsref jsref sort asp  Might suffice for small arrays with flat JSON schemas

User · Answer

I know this is a bit old  but I would like to add a solution that I came up with for this problem  I had an object  and I wanted to know when its data changed   something similar to Object observe  and what I did was   function checkObjects obj obj2      var values          var keys          keys   Object keys obj      keys forEach function key         values push key             var values2          var keys2          keys2   Object keys obj2      keys2 forEach function key         values2 push key             return  values    values2  amp  amp  keys    keys2      This here can be duplicated and create an other set of arrays to compare the values and keys  It is very simple because they are now arrays and will return false if objects have different sizes

User · Answer

I m making the following assumptions with this function    You control the objects you are comparing and you only have primitive values  ie  not nested objects  functions  etc    Your browser has support for Object keys    This should be treated as a demonstration of a simple strategy          Checks the equality of two objects that contain primitive values   ie  no nested objects  functions  etc       param  Object  object1     param  Object  object2     param  Boolean   order matters  Affects the return value of unordered objects   ex   a 1  b 2  and  b 2  a 1        returns  Boolean      function isEqual  object1  object2  order matters         var keys1   Object keys object1           keys2   Object keys object2           i  key          Test 1  Same number of elements     if  keys1 length    keys2 length             return false                If order doesn t matter isEqual  a 2  b 1    b 1  a 2   should return true         keys1   Object keys  a 2  b 1       a   b           keys2   Object keys  b 1  a 2       b   a           This is why we are sorting keys1 and keys2      if   order matters             keys1 sort            keys2 sort                  Test 2  Same keys     for  i   0  i  lt  keys1 length  i               if  keys1 i     keys2 i                  return false                          Test 3  Values     for  i   0  i  lt  keys1 length  i               key   keys1 i           if  object1 key     object2 key                  return false                       return true

User · Answer

After so much of searches  i have found following working solution  function isEquivalent a  b          Create arrays of property names    var aProps   Object getOwnPropertyNames a      var bProps   Object getOwnPropertyNames b         If number of properties is different  objects are not equivalent   if  aProps length    bProps length         return false         for  var i   0  i  lt  aProps length  i           var propName   aProps i           If values of same property are not equal  objects are not equivalent      if  a propName      b propName              return false                 If we made it this far  objects are considered equivalent return true      For more info  Object Equality in JavaScript

User · Answer

If you are working in AngularJS  the angular equals function will determine if two objects are equal  In Ember js use isEqual    angular equals - See the docs or source for more on this method  It does a deep compare on arrays too  Ember js isEqual - See the docs or source for more on this method  It does not do a deep compare on arrays     x000D   x000D  var purple      purple    drank     x000D  var drank      purple    drank     x000D   x000D  if angular equals purple  drank     x000D      document write  got dat    x000D    x000D   lt script src  https   ajax googleapis com ajax libs angularjs 1 4 5 angular min js  gt  lt  script gt  x000D   x000D   x000D

User · Answer

Are you trying to test if two objects are the equal  ie  their properties are equal   If this is the case  you ll probably have noticed this situation   var a     foo    bar     var b     foo    bar     alert  a    b    Equal     Not equal        Not equal    you might have to do something like this   function objectEquals obj1  obj2        for  var i in obj1            if  obj1 hasOwnProperty i                 if   obj2 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      for  var i in obj2            if  obj2 hasOwnProperty i                 if   obj1 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      return true      Obviously that function could do with quite a bit of optimisation  and the ability to do deep checking  to handle nested objects  var a     foo     fu    bar       but you get the idea   As FOR pointed out  you might have to adapt this for your own purposes  eg  different classes may have different definitions of  equal   If you re just working with plain objects  the above may suffice  otherwise a custom MyClass equals   function may be the way to go

User · Answer

If you are using a JSON library  you can encode each object as JSON  then compare the resulting strings for equality   var obj1  test  value    var obj2  test  value2     alert JSON encode obj1    JSON encode obj2      NOTE  While this answer will work in many cases  as several people have pointed out in the comments it s problematic for a variety of reasons  In pretty much all cases you ll want to find a more robust solution

User · Answer

var object1    name   humza    gender    male   age  23  var object2    name   humza    gender    male   age  23  var result   Object keys object1  every  key    gt   object1 key      object2 key     Result will be true if object1 has same values on object2

User · Answer

sort the objects  dictionary  compare JSON string  function areTwoDictsEqual dictA  dictB        function sortDict dict            var keys   Object keys dict           keys sort             var newDict               for  var i 0  i lt keys length  i                  var key   keys i               var value   dict key               newDict key    value                     return newDict             return JSON stringify sortDict dictA      JSON stringify sortDict dictB

User · Answer

Heres s a solution in ES6 ES2015 using a functional-style approach   const typeOf   x   gt          toString        call x         match    object   w       1   function areSimilar a  b      const everyKey   f   gt  Object keys a  every f     switch typeOf a         case  Array         return a length     b length  amp  amp          everyKey k   gt  areSimilar a sort   k   b sort   k         case  Object         return Object keys a  length     Object keys b  length  amp  amp          everyKey k   gt  areSimilar a k   b k         default        return a     b          demo available here

User · Answer

After so much of searches  i have found following working solution  function isEquivalent a  b          Create arrays of property names    var aProps   Object getOwnPropertyNames a      var bProps   Object getOwnPropertyNames b         If number of properties is different  objects are not equivalent   if  aProps length    bProps length         return false         for  var i   0  i  lt  aProps length  i           var propName   aProps i           If values of same property are not equal  objects are not equivalent      if  a propName      b propName              return false                 If we made it this far  objects are considered equivalent return true      For more info  Object Equality in JavaScript

User · Answer

const one  name  mohit    age 30     const two   name  mohit  age 30   const two   age 30 name  mohit     function isEquivalent a  b       Create arrays of property names var aProps   Object getOwnPropertyNames a   var bProps   Object getOwnPropertyNames b         If number of properties is different     objects are not equivalent if  aProps length    bProps length        return false     for  var i   0  i  lt  aProps length  i          var propName   aProps i           If values of same property are not equal         objects are not equivalent     if  a propName      b propName             return false              If we made it this far  objects    are considered equivalent return true     console log isEquivalent one two

User · Answer

x000D   x000D       let user1     x000D          name   John   x000D          address    x000D              line1   55 Green Park Road   x000D              line2    x000D                a  1 2 3  x000D                 x000D             x000D          email null x000D            x000D       x000D       let user2     x000D          name   John   x000D          address    x000D              line1   55 Green Park Road   x000D              line2    x000D                a  1 2 3  x000D                 x000D             x000D          email null x000D             x000D       x000D         Method 1 x000D       x000D      function isEqual a  b    x000D            return JSON stringify a      JSON stringify b   x000D        x000D       x000D         Method 2 x000D       x000D      function isEqual a  b    x000D           checking type of a And b x000D        if typeof a      object     typeof b      object     x000D          return false  x000D          x000D         x000D           Both are NULL x000D        if  a  amp  amp   b     x000D           return true  x000D          else if  a     b    x000D           return false  x000D          x000D         x000D        let keysA   Object keys a   x000D        let keysB   Object keys b   x000D        if keysA length     keysB length    x000D          return false  x000D          x000D        for let key in a    x000D         if   key in b     x000D           return false  x000D           x000D           x000D         if typeof a key       object     x000D           if  isEqual a key   b key    x000D               x000D               return false  x000D               x000D           else   x000D           if a key      b key     x000D             return false  x000D             x000D           x000D          x000D         x000D        return true  x000D        x000D   x000D   x000D   x000D  console log isEqual user1 user2    x000D   x000D   x000D

User · Answer

Simplest and logical solutions for comparing everything Like Object  Array  String  Int     JSON stringify  a  val1       JSON stringify  a  val2    Note     you need to replace val1and val2 with your Object for the object  you have to sort by key  recursively for both side objects

User · Answer

I m not a Javascript expert  but here is one simple attempt to solve it  I check for three things    Is it an object and also that it is not null because typeof null is object  If the property count of the two objects is the same  If not they are not equal  Loop through properties of one and check if corresponding property has same value in second object     x000D   x000D  function deepEqual  first  second    x000D       Not equal if either is not an object or is null  x000D    if   isObject first      isObject second    return false  x000D   x000D       If properties count is different x000D    if  keys first  length    keys second  length  return false  x000D   x000D       Return false if any property value is different  x000D    for prop in first   x000D      if  first prop     second prop   return false  x000D      x000D    return true  x000D    x000D   x000D     Checks if argument is an object and is not null x000D  function isObject obj    x000D    return  typeof obj      object   amp  amp  obj    null   x000D    x000D   x000D     returns arrays of object keys x000D  function keys  obj    x000D    result       x000D    for var key in obj   x000D      result push key   x000D      x000D    return result  x000D    x000D   x000D     Some test code x000D  obj1     x000D    name   Singh   x000D    age  20 x000D    x000D   x000D  obj2     x000D    age  20  x000D    name   Singh  x000D    x000D   x000D  obj3     x000D    name   Kaur   x000D    age  19 x000D    x000D   x000D  console log deepEqual obj1  obj2    x000D  console log deepEqual obj1  obj3    x000D   x000D   x000D

User · Answer

This is an addition for all the above  not a replacement  If you need to fast shallow-compare objects without need to check extra recursive cases  Here is a shot   This compares for  1  Equality of number of own properties  2  Equality of key names  3  if bCompareValues    true  Equality of corresponding property values and their types  triple equality   var shallowCompareObjects   function o1  o2  bCompareValues        var s           n1   0          n2   0          b    true       for  s in o1    n1           for  s in o2             if   o1 hasOwnProperty s                 b   false              break                    if  bCompareValues  amp  amp  o1 s      o2 s                 b   false              break                    n2               return b  amp  amp  n1    n2

User · Answer

I see spaghetti code answers  Without using any third party libs  this is very easy   Firstly sort the two objects by key their key names   let objectOne     hey  you   let objectTwo     you  hey       If you really wanted you could make this recursive for deep sort  const sortObjectByKeyname    objectToSort    gt        return Object keys objectToSort  sort   reduce  r  k    gt   r k    objectToSort k   r           let objectOne   sortObjectByKeyname objectOne  let objectTwo   sortObjectByKeyname objectTwo    Then simply use a string to compare them   JSON stringify objectOne      JSON stringify objectTwo

User · Answer

If you are using a JSON library  you can encode each object as JSON  then compare the resulting strings for equality   var obj1  test  value    var obj2  test  value2     alert JSON encode obj1    JSON encode obj2      NOTE  While this answer will work in many cases  as several people have pointed out in the comments it s problematic for a variety of reasons  In pretty much all cases you ll want to find a more robust solution

User · Answer

Depends on what you mean by equality  And therefore it is up to you  as the developer of the classes  to define their equality   There s one case used sometimes  where two instances are considered  equal  if they point to the same location in memory  but that is not always what you want  For instance  if I have a Person class  I might want to consider two Person objects  equal  if they have the same Last Name  First Name  and Social Security Number  even if they point to different locations in memory    On the other hand  we can t simply say that two objects are equal if the value of each of their members is the same  since  sometimes  you don t want that  In other words  for each class  it s up to the class developer to define what members make up the objects  identity  and develop a proper equality operator  be it via overloading the    operator or an Equals method    Saying that two objects are equal if they have the same hash is one way out  However you then have to wonder how the hash is calculated for each instance  Going back to the Person example above  we could use this system if the hash was calculated by looking at the values of the First Name  Last Name  and Social Security Number fields  On top of that  we are then relying on the quality of the hashing method  that s a huge topic on its own  but suffice it to say that not all hashes are created equal  and bad hashing methods can lead to more collisions  which in this case would return false matches

User · Answer

The short answer  The simple answer is  No  there is no generic means to determine that an object is equal to another in the sense you mean  The exception is when you are strictly thinking of an object being typeless   The long answer  The concept is that of an Equals method that compares two different instances of an object to indicate whether they are equal at a value level  However  it is up to the specific type to define how an Equals method should be implemented  An iterative comparison of attributes that have primitive values may not be enough  there may well be attributes which are not to be considered part of the object value  For example    function MyClass a  b          var c       this getCLazy   function              if  c     undefined  c   a   b    imagine   is really expensive          return c               In this above case  c is not really important to determine whether any two instances of MyClass are equal  only a and b are important  In some cases c might vary between instances and yet not be significant during comparison    Note this issue applies when members may themselves also be instances of a type and these each would all be required to have a means of determining equality   Further complicating things is that in JavaScript the distinction between data and method is blurred   An object may reference a method that is to be called as an event handler  and this would likely not be considered part of its  value state   Whereas another object may well be assigned a function that performs an important calculation and thereby makes this instance different from others simply because it references a different function   What about an object that has one of its existing prototype methods overridden by another function  Could it still be considered equal to another instance that it otherwise identical  That question can only be answered in each specific case for each type   As stated earlier  the exception would be a strictly typeless object  In which case the only sensible choice is an iterative and recursive comparison of each member  Even then one has to ask what is the  value  of a function

User · Answer

Yeah  another answer      x000D   x000D  Object prototype equals   function  object    x000D      if  this constructor     object constructor  return false  x000D      if  Object keys this  length     Object keys object  length  return false  x000D      var obk  x000D      for  obk in object    x000D          if  this obk      object obk   x000D              return false  x000D        x000D      return true  x000D    x000D   x000D  var aaa   JSON parse    name   mike   tel   1324356584      x000D  var bbb   JSON parse    tel   1324356584   name   mike      x000D  var ccc   JSON parse    name   mike   tel   584      x000D  var ddd   JSON parse    name   mike   tel   1324356584    work   nope      x000D   x000D      ab   text aaa equals bbb    x000D      ba   text bbb equals aaa    x000D      bc   text bbb equals ccc    x000D      ad   text aaa equals ddd    x000D   lt script src  https   ajax googleapis com ajax libs jquery 2 1 1 jquery min js  gt  lt  script gt  x000D  aaa equals bbb   lt span id  ab  gt  lt  span gt   lt br  gt  x000D  bbb equals aaa   lt span id  ba  gt  lt  span gt   lt br  gt  x000D  bbb equals ccc   lt span id  bc  gt  lt  span gt   lt br  gt  x000D  aaa equals ddd   lt span id  ad  gt  lt  span gt  x000D   x000D   x000D

User · Answer

The short answer  The simple answer is  No  there is no generic means to determine that an object is equal to another in the sense you mean  The exception is when you are strictly thinking of an object being typeless   The long answer  The concept is that of an Equals method that compares two different instances of an object to indicate whether they are equal at a value level  However  it is up to the specific type to define how an Equals method should be implemented  An iterative comparison of attributes that have primitive values may not be enough  there may well be attributes which are not to be considered part of the object value  For example    function MyClass a  b          var c       this getCLazy   function              if  c     undefined  c   a   b    imagine   is really expensive          return c               In this above case  c is not really important to determine whether any two instances of MyClass are equal  only a and b are important  In some cases c might vary between instances and yet not be significant during comparison    Note this issue applies when members may themselves also be instances of a type and these each would all be required to have a means of determining equality   Further complicating things is that in JavaScript the distinction between data and method is blurred   An object may reference a method that is to be called as an event handler  and this would likely not be considered part of its  value state   Whereas another object may well be assigned a function that performs an important calculation and thereby makes this instance different from others simply because it references a different function   What about an object that has one of its existing prototype methods overridden by another function  Could it still be considered equal to another instance that it otherwise identical  That question can only be answered in each specific case for each type   As stated earlier  the exception would be a strictly typeless object  In which case the only sensible choice is an iterative and recursive comparison of each member  Even then one has to ask what is the  value  of a function

User · Answer

ES6  The minimum code I could get it done  is this  It do deep comparison recursively by stringifying all key value array sorted representing the object  the only limitation is no methods or symbols are compare   x000D   x000D  const compareObjects    a  b    gt       let s    o    gt  Object entries o  sort   map i   gt          if i 1  instanceof Object  i 1    s i 1         return i          return JSON stringify s a       JSON stringify s b      console log compareObjects  b 4 a  b 1     a  b 1  b 4     x000D   x000D   x000D   IMPORTANT  This function is doing a JSON stringfy in an ARRAY with the keys sorted and NOT in the object it self     quot a quot     quot b quot   1     quot b quot   4

User · Answer

Yeah  another answer      x000D   x000D  Object prototype equals   function  object    x000D      if  this constructor     object constructor  return false  x000D      if  Object keys this  length     Object keys object  length  return false  x000D      var obk  x000D      for  obk in object    x000D          if  this obk      object obk   x000D              return false  x000D        x000D      return true  x000D    x000D   x000D  var aaa   JSON parse    name   mike   tel   1324356584      x000D  var bbb   JSON parse    tel   1324356584   name   mike      x000D  var ccc   JSON parse    name   mike   tel   584      x000D  var ddd   JSON parse    name   mike   tel   1324356584    work   nope      x000D   x000D      ab   text aaa equals bbb    x000D      ba   text bbb equals aaa    x000D      bc   text bbb equals ccc    x000D      ad   text aaa equals ddd    x000D   lt script src  https   ajax googleapis com ajax libs jquery 2 1 1 jquery min js  gt  lt  script gt  x000D  aaa equals bbb   lt span id  ab  gt  lt  span gt   lt br  gt  x000D  bbb equals aaa   lt span id  ba  gt  lt  span gt   lt br  gt  x000D  bbb equals ccc   lt span id  bc  gt  lt  span gt   lt br  gt  x000D  aaa equals ddd   lt span id  ad  gt  lt  span gt  x000D   x000D   x000D

User · Answer

I have a much shorter function that will go deep into all sub objects or arrays  It is as efficient as JSON stringify obj1      JSON stringify obj2  but JSON stringify will not work if the order is not the same  as mentioned here    var obj1     a   1  b   2    var obj2     b   2  a   1     console log JSON stringify obj1      JSON stringify obj2       false   The function would also be a good start if you want to do something with the unequal values    x000D   x000D  function arr or obj v  x000D    return   v  amp  amp   v constructor     Object    v constructor     Array     x000D   x000D  function deep equal v1  v2  x000D    x000D      if  arr or obj v1   amp  amp  arr or obj v2   amp  amp  v1 constructor     v2 constructor  x000D        x000D          if  Object keys v1  length     Object keys v2  length     check the length x000D          for  var i in v1  x000D            x000D              if   deep equal v1 i   v2 i    x000D                return false    x000D            x000D          else x000D            return false    x000D        x000D      else if  v1     v2  x000D        return false    x000D   x000D      return true  x000D    x000D   x000D                                                                     x000D                                                                     x000D   x000D  var obj1     x000D        x000D          hat     x000D              cap     something   null    x000D              helmet      triple eight    pro-tec    x000D             x000D          shoes      loafer    penny    x000D         x000D        x000D          beers      budweiser    busch     x000D          wines      barefoot    yellow tail    x000D        x000D     x000D   x000D  var obj2     x000D        x000D          shoes      loafer    penny        same even if the order is different x000D          hat     x000D              cap     something   null    x000D              helmet      triple eight    pro-tec    x000D            x000D         x000D        x000D          beers      budweiser    busch     x000D          wines      barefoot    yellow tail    x000D        x000D     x000D   x000D  console log deep equal obj1  obj2       true x000D  console log JSON stringify obj1      JSON stringify obj2       false x000D  console log deep equal              true x000D  console log deep equal              true x000D  console log deep equal              false x000D   x000D   x000D    And if you want to add support for Function  Date and RegExp  you can add this at the beginning of deep equal  not tested    if   typeof obj1      function   amp  amp  typeof obj2      function       obj1 instanceof Date  amp  amp  obj2 instanceof Date      obj1 instanceof RegExp  amp  amp  obj2 instanceof RegExp         obj1   obj1 toString        obj2   obj2 toString

User · Answer

Depending  If the order of keys in the object are not of importance  and I don t need to know the prototypes of the said object  Using always do the job   const object       JSON stringify object           will pass but             will not

User · Answer

I don t know if anyone s posted anything similar to this  but here s a function I made to check for object equalities   function objectsAreEqual a  b      for  var prop in a        if  a hasOwnProperty prop           if  b hasOwnProperty prop             if  typeof a prop       object               if   objectsAreEqual a prop   b prop    return false            else             if  a prop      b prop   return false                    else           return false                      return true      Also  it s recursive  so it can also check for deep equality  if that s what you call it

User · Answer

The short answer  The simple answer is  No  there is no generic means to determine that an object is equal to another in the sense you mean  The exception is when you are strictly thinking of an object being typeless   The long answer  The concept is that of an Equals method that compares two different instances of an object to indicate whether they are equal at a value level  However  it is up to the specific type to define how an Equals method should be implemented  An iterative comparison of attributes that have primitive values may not be enough  there may well be attributes which are not to be considered part of the object value  For example    function MyClass a  b          var c       this getCLazy   function              if  c     undefined  c   a   b    imagine   is really expensive          return c               In this above case  c is not really important to determine whether any two instances of MyClass are equal  only a and b are important  In some cases c might vary between instances and yet not be significant during comparison    Note this issue applies when members may themselves also be instances of a type and these each would all be required to have a means of determining equality   Further complicating things is that in JavaScript the distinction between data and method is blurred   An object may reference a method that is to be called as an event handler  and this would likely not be considered part of its  value state   Whereas another object may well be assigned a function that performs an important calculation and thereby makes this instance different from others simply because it references a different function   What about an object that has one of its existing prototype methods overridden by another function  Could it still be considered equal to another instance that it otherwise identical  That question can only be answered in each specific case for each type   As stated earlier  the exception would be a strictly typeless object  In which case the only sensible choice is an iterative and recursive comparison of each member  Even then one has to ask what is the  value  of a function

User · Answer

This is a simple Javascript function to compare two objects having simple key-value pairs  The function will return an array of strings  where each string is a path to an inequality between the two objects   function compare a b        var paths               new Set Object keys a  concat Object keys b     forEach key  gt           if typeof a key       object   amp  amp  typeof b key       object                 var results   compare a key   b key                if JSON stringify results                            paths push    results map result  gt key concat    gt   result                                     else if  a key    b key                 paths push key                        return paths      If you only want to compare two objects without knowing the paths to inequalities  you can do it as follows   if JSON stringify compare object1  object2                   the two objects are equal   else         the two objects are not equal

User · Answer

I ve written a small library that runs on Node js and the browser called compare js  It offers the usual comparison operators  such as                 lt    lt   and identity on all data types of JavaScript   E g   you can use  cmp eq obj1  obj2     and this will check for equality  using a deep-equal approach   Otherwise  if you do  cmp id obj1  obj2     it will compare by reference  hence check for identity  You can also use  lt  and   on objects  which mean subset and superset   compare js is covered by nearly 700 unit tests  hence it should hopefully not have too many bugs  -    You can find it on https   github com goloroden compare js for free  it is open-sourced under the MIT license

User · Answer

Why reinvent the wheel  Give Lodash a try  It has a number of must-have functions such as isEqual       isEqual object  other     It will brute force check each key value - just like the other examples on this page - using ECMAScript nbsp 5 and native optimizations if they re available in the browser   Note  Previously this answer recommended Underscore js  but lodash has done a better job of getting bugs fixed and addressing issues with consistency

User · Answer

Short functional deepEqual implementation   function deepEqual x  y      return  x  amp  amp  y  amp  amp  typeof x      object   amp  amp  typeof y      object          Object keys x  length     Object keys y  length   amp  amp        Object keys x  reduce function isEqual  key            return isEqual  amp  amp  deepEqual x key   y key             true     x     y       Edit  version 2  using jib s suggestion and ES6 arrow functions   function deepEqual x  y      const ok   Object keys  tx   typeof x  ty   typeof y    return x  amp  amp  y  amp  amp  tx      object   amp  amp  tx     ty         ok x  length     ok y  length  amp  amp        ok x  every key   gt  deepEqual x key   y key           x     y

User · Answer

Pulling out from my personal library  which i use for my work repeatedly  The following function is a lenient recursive deep equal  which does not check   Class equality Inherited values Values strict equality   I mainly use this to check if i get equal replies against various API implementation  Where implementation difference  like string vs number  and additional null values  can occur    Its implementation is quite straightforward and short  if all the comments is stripped off    x000D   x000D      Recursively check if both objects are equal in value x000D      x000D      This function is designed to use multiple methods from most probable  x000D       and in most cases  valid  to the more regid and complex method  x000D      x000D      One of the main principles behind the various check is that while x000D      some of the simpler checks such as    or JSON may cause false negatives  x000D      they do not cause false positives  As such they can be safely run first  x000D      x000D         Important Note  x000D      as this function is designed for simplified deep equal checks it is not designed x000D      for the following x000D      x000D      - Class equality   ClassA   a   1  maybe valid to  ClassB   b   1  x000D      - Inherited values  this actually ignores them x000D      - Values being strictly equal   1  is equal to 1  see the basic equality check on this  x000D      - Performance across all cases  This is designed for high performance on the x000D        most probable cases of      JSON equality  Consider bench testing  if you have x000D        more  complex  requirments x000D      x000D       param  objA   First object to compare x000D       param  objB   2nd object to compare x000D       param         Any other objects to compare x000D      x000D       returns true if all equals  or false if invalid x000D      x000D       license Copyright by eugene picoded com  2012  x000D               Licensed under the MIT license  http   opensource org licenses MIT x000D      x000D  function simpleRecusiveDeepEqual objA  objB    x000D      Multiple comparision check x000D     -------------------------------------------- x000D   var args   Array prototype slice call arguments   x000D   if args length  gt  2    x000D    for var a 1  a lt args length    a    x000D     if  simpleRecusiveDeepEqual args a-1   args a      x000D      return false  x000D       x000D      x000D    return true  x000D     else if args length  lt  2    x000D    throw  simpleRecusiveDeepEqual  requires atleast 2 arguments   x000D     x000D    x000D      basic equality check  x000D     -------------------------------------------- x000D      if this succed the 2 basic values is equal  x000D      such as numbers and string  x000D      x000D      or its actually the same object pointer  Bam x000D      x000D      Note that if string and number strictly equal is required x000D      change the equality from     to     x000D      x000D   if objA    objB    x000D    return true  x000D     x000D    x000D      If a value is a bsic type  and failed above  This fails x000D   var basicTypes     boolean    number    string    x000D   if  basicTypes indexOf typeof objA   gt   0    basicTypes indexOf typeof objB   gt   0     x000D    return false  x000D     x000D    x000D      JSON equality check  x000D     -------------------------------------------- x000D      this can fail  if the JSON stringify the objects in the wrong order x000D      for example the following may fail  due to different string order  x000D      x000D      JSON stringify   a 1  b 2       JSON stringify   b 2  a 1    x000D      x000D   if JSON stringify objA     JSON stringify objB     x000D    return true  x000D     x000D    x000D      Array equality check x000D     -------------------------------------------- x000D      This is performed prior to iteration check  x000D      Without this check the following would have been considered valid x000D      x000D      simpleRecusiveDeepEqual    0 1963     1963     x000D      x000D      Note that u may remove this segment if this is what is intended x000D      x000D   if  Array isArray objA      x000D      objA is array  objB is not an array x000D    if   Array isArray objB      x000D     return false  x000D      x000D     else if  Array isArray objB      x000D      objA is not array  objB is an array x000D    return false  x000D     x000D    x000D      Nested values iteration x000D     -------------------------------------------- x000D      Scan and iterate all the nested values  and check for non equal values recusively x000D      x000D      Note that this does not check against null equality  remove the various     null  x000D      if this is required x000D    x000D   var i    reuse var to iterate x000D    x000D      Check objA values against objB x000D   for  i in objA    x000D      Protect against inherited properties x000D    if objA hasOwnProperty i     x000D     if objB hasOwnProperty i     x000D         Check if deep equal is valid x000D      if  simpleRecusiveDeepEqual  objA i   objB i       x000D       return false  x000D        x000D       else if objA i     null    x000D        ignore null values in objA  that objB does not have x000D        else fails x000D      return false  x000D       x000D      x000D     x000D    x000D      Check if objB has additional values  that objA do not  fail if so x000D   for  i in objB    x000D    if objB hasOwnProperty i     x000D     if objB i     null  amp  amp   objA hasOwnProperty i     x000D        ignore null values in objB  that objA does not have x000D        else fails x000D      return false  x000D       x000D      x000D     x000D    x000D      End of all checks x000D     -------------------------------------------- x000D      By reaching here  all iteration scans have been done  x000D      and should have returned false if it failed x000D   return true  x000D    x000D   x000D     Sanity checking of simpleRecusiveDeepEqual x000D   function     x000D   if  x000D       Basic checks x000D     simpleRecusiveDeepEqual            x000D     simpleRecusiveDeepEqual            x000D     simpleRecusiveDeepEqual   a      a       x000D       Not strict checks x000D     simpleRecusiveDeepEqual  1   1     x000D       Multiple objects check x000D     simpleRecusiveDeepEqual    a  1 2       a  1 2       a  1 2         x000D       Ensure distinction between array and object  the following should fail  x000D    simpleRecusiveDeepEqual   1963     0 1963        x000D       Null strict checks x000D    simpleRecusiveDeepEqual  0  null      x000D    simpleRecusiveDeepEqual      null      x000D       Last  false  exists to make the various check above easy to comment in out x000D    false x000D       x000D    alert  FATAL ERROR  simpleRecusiveDeepEqual failed basic checks    x000D     else    x000D      added this last line  for SO snippet alert on success x000D    alert  simpleRecusiveDeepEqual  Passed all checks  Yays     x000D     x000D        x000D   x000D   x000D

User · Answer

If you are comparing JSON objects you can use https   github com mirek node-rus-diff  npm install rus-diff   Usage   a    foo  bar 1   b    foo  bar 1   c    foo  bar 2    var rusDiff   require  rus-diff   rusDiff  console log rusDiff a  b      - gt  false  meaning a and b are equal console log rusDiff a  c      - gt      set      foo bar   2       If two objects are different  a MongoDB compatible   rename         unset         set        like object is returned

User · Answer

I don t know if anyone s posted anything similar to this  but here s a function I made to check for object equalities   function objectsAreEqual a  b      for  var prop in a        if  a hasOwnProperty prop           if  b hasOwnProperty prop             if  typeof a prop       object               if   objectsAreEqual a prop   b prop    return false            else             if  a prop      b prop   return false                    else           return false                      return true      Also  it s recursive  so it can also check for deep equality  if that s what you call it

User · Answer

Depends on what you mean by equality  And therefore it is up to you  as the developer of the classes  to define their equality   There s one case used sometimes  where two instances are considered  equal  if they point to the same location in memory  but that is not always what you want  For instance  if I have a Person class  I might want to consider two Person objects  equal  if they have the same Last Name  First Name  and Social Security Number  even if they point to different locations in memory    On the other hand  we can t simply say that two objects are equal if the value of each of their members is the same  since  sometimes  you don t want that  In other words  for each class  it s up to the class developer to define what members make up the objects  identity  and develop a proper equality operator  be it via overloading the    operator or an Equals method    Saying that two objects are equal if they have the same hash is one way out  However you then have to wonder how the hash is calculated for each instance  Going back to the Person example above  we could use this system if the hash was calculated by looking at the values of the First Name  Last Name  and Social Security Number fields  On top of that  we are then relying on the quality of the hashing method  that s a huge topic on its own  but suffice it to say that not all hashes are created equal  and bad hashing methods can lead to more collisions  which in this case would return false matches

User · Answer

ES6  The minimum code I could get it done  is this  It do deep comparison recursively by stringifying all key value array sorted representing the object  the only limitation is no methods or symbols are compare   x000D   x000D  const compareObjects    a  b    gt       let s    o    gt  Object entries o  sort   map i   gt          if i 1  instanceof Object  i 1    s i 1         return i          return JSON stringify s a       JSON stringify s b      console log compareObjects  b 4 a  b 1     a  b 1  b 4     x000D   x000D   x000D   IMPORTANT  This function is doing a JSON stringfy in an ARRAY with the keys sorted and NOT in the object it self     quot a quot     quot b quot   1     quot b quot   4

User · Answer

One additional option  is use equals of Ramda library  const c    a  1  b  2   const d    b  2  a  1   R equals c  d       gt  true

User · Answer

Are you trying to test if two objects are the equal  ie  their properties are equal   If this is the case  you ll probably have noticed this situation   var a     foo    bar     var b     foo    bar     alert  a    b    Equal     Not equal        Not equal    you might have to do something like this   function objectEquals obj1  obj2        for  var i in obj1            if  obj1 hasOwnProperty i                 if   obj2 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      for  var i in obj2            if  obj2 hasOwnProperty i                 if   obj1 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      return true      Obviously that function could do with quite a bit of optimisation  and the ability to do deep checking  to handle nested objects  var a     foo     fu    bar       but you get the idea   As FOR pointed out  you might have to adapt this for your own purposes  eg  different classes may have different definitions of  equal   If you re just working with plain objects  the above may suffice  otherwise a custom MyClass equals   function may be the way to go

User · Answer

I need to mock jQuery POST requests  so the equality that matters to me is that both objects have the same set of properties  none missing in either object   and that each property value is  equal   according to this definition    I don t care about the objects having mismatching methods   Here s what I ll be using  it should be good enough for my specific requirements   function PostRequest         for  var i   0  i  lt  arguments length  i    2            this arguments i     arguments i 1              var compare   function u  v            if  typeof u     typeof v                 return false                     var allkeys               for  var i in u                allkeys i    1                    for  var i in v                allkeys i    1                    for  var i in allkeys                if  u hasOwnProperty i     v hasOwnProperty i                     if   u hasOwnProperty i   amp  amp  typeof u i       function                           v hasOwnProperty i   amp  amp  typeof v i       function                          continue                    else                       return false                                              if  typeof u i      typeof v i                      return false                            if  typeof u i       object                     if   compare u i   v i                          return false                                  else                   if  u i      v i                         return false                                                     return true              this equals   function o            return compare this  o               return this      Use like so   foo   new PostRequest  text    hello    html     lt p gt hello lt  p gt     foo equals   html    lt p gt hello lt  p gt    text   hello

User · Answer

I d advise against hashing or serialization  as the JSON solution suggest    If you need to test if two objects are equal  then you need to define what equals means   It could be that all data members in both objects match  or it could be that must the memory locations match  meaning both variables reference the same object in memory   or may be that only one data member in each object must match   Recently I developed an object whose constructor creates a new id  starting from 1 and incrementing by 1  each time an instance is created   This object has an isEqual function that compares that id value with the id value of another object and returns true if they match   In that case I defined  equal  as meaning the the id values match   Given that each instance has a unique id this could be used to enforce the idea that matching objects also occupy the same memory location   Although that is not necessary

User · Answer

Short functional deepEqual implementation   function deepEqual x  y      return  x  amp  amp  y  amp  amp  typeof x      object   amp  amp  typeof y      object          Object keys x  length     Object keys y  length   amp  amp        Object keys x  reduce function isEqual  key            return isEqual  amp  amp  deepEqual x key   y key             true     x     y       Edit  version 2  using jib s suggestion and ES6 arrow functions   function deepEqual x  y      const ok   Object keys  tx   typeof x  ty   typeof y    return x  amp  amp  y  amp  amp  tx      object   amp  amp  tx     ty         ok x  length     ok y  length  amp  amp        ok x  every key   gt  deepEqual x key   y key           x     y

User · Answer

I need to mock jQuery POST requests  so the equality that matters to me is that both objects have the same set of properties  none missing in either object   and that each property value is  equal   according to this definition    I don t care about the objects having mismatching methods   Here s what I ll be using  it should be good enough for my specific requirements   function PostRequest         for  var i   0  i  lt  arguments length  i    2            this arguments i     arguments i 1              var compare   function u  v            if  typeof u     typeof v                 return false                     var allkeys               for  var i in u                allkeys i    1                    for  var i in v                allkeys i    1                    for  var i in allkeys                if  u hasOwnProperty i     v hasOwnProperty i                     if   u hasOwnProperty i   amp  amp  typeof u i       function                           v hasOwnProperty i   amp  amp  typeof v i       function                          continue                    else                       return false                                              if  typeof u i      typeof v i                      return false                            if  typeof u i       object                     if   compare u i   v i                          return false                                  else                   if  u i      v i                         return false                                                     return true              this equals   function o            return compare this  o               return this      Use like so   foo   new PostRequest  text    hello    html     lt p gt hello lt  p gt     foo equals   html    lt p gt hello lt  p gt    text   hello

User · Answer

Lot s of good thoughts here  Here is my version of deep equal  I posted it on github and wrote some tests around it  It s hard to cover all the possible cases and sometimes it s unnecessary to do so    I covered NaN     NaN as well as circular dependencies   https   github com ryancat simple-deep-equal blob master index js

User · Answer

I faced the same problem and deccided to write my own solution  But because I want to also compare Arrays with Objects and vice-versa  I crafted a generic solution  I decided to add the functions to the prototype  but one can easily rewrite them to standalone functions  Here is the code   Array prototype equals   Object prototype equals   function b        var ar   JSON parse JSON stringify b        var err   false      for var key in this            if this hasOwnProperty key                 var found   ar find this key                if found  gt  -1                    if Object prototype toString call ar        object Object                          delete ar Object keys ar  found                                      else                       ar splice found  1                                               else                   err   true                  break                                     if Object keys ar  length  gt  0    err            return false            return true     Array prototype find   Object prototype find   function v        var f   -1      for var i in this            if this hasOwnProperty i                 if Object prototype toString call this i         object Array      Object prototype toString call this i         object Object                      if this i  equals v                         f    typeof i      number     i   Object keys this  indexOf i                                               else if this i      v                    f    typeof i      number     i   Object keys this  indexOf i                                     return f      This Algorithm is split into two parts  The equals function itself and a function to find the numeric index of a property in an array   object  The find function is only needed because indexof only finds numbers and strings and no objects    One can call it like this     a  1  b   h    equals  a  1  b   h       The function either returns true or false  in this case true  The algorithm als allows comparison between very complex objects     a  1  b   hello   c    w    o    r    l    d    answer1   should be   answer2  true     equals  b   hello   a  1  c    w    d    o    r    answer1   should be   answer2  true    l       The upper example will return true  even tho the properties have a different ordering  One small detail to look out for  This code also checks for the same type of two variables  so  3  is not the same as 3

User · Answer

For comparing keys for simple key value pairs object instances  I use   function compareKeys r1  r2        var nloops   0  score   0      for k1 in r1            for k2 in r2                nloops                if k1    k2                  score                         return nloops     score   score        Once keys are compared  a simple additional for  in loop is enough   Complexity is O N N  with N is the number of keys    I hope guess objects I define won t hold more than 1000 properties

User · Answer

I faced the same problem and deccided to write my own solution  But because I want to also compare Arrays with Objects and vice-versa  I crafted a generic solution  I decided to add the functions to the prototype  but one can easily rewrite them to standalone functions  Here is the code   Array prototype equals   Object prototype equals   function b        var ar   JSON parse JSON stringify b        var err   false      for var key in this            if this hasOwnProperty key                 var found   ar find this key                if found  gt  -1                    if Object prototype toString call ar        object Object                          delete ar Object keys ar  found                                      else                       ar splice found  1                                               else                   err   true                  break                                     if Object keys ar  length  gt  0    err            return false            return true     Array prototype find   Object prototype find   function v        var f   -1      for var i in this            if this hasOwnProperty i                 if Object prototype toString call this i         object Array      Object prototype toString call this i         object Object                      if this i  equals v                         f    typeof i      number     i   Object keys this  indexOf i                                               else if this i      v                    f    typeof i      number     i   Object keys this  indexOf i                                     return f      This Algorithm is split into two parts  The equals function itself and a function to find the numeric index of a property in an array   object  The find function is only needed because indexof only finds numbers and strings and no objects    One can call it like this     a  1  b   h    equals  a  1  b   h       The function either returns true or false  in this case true  The algorithm als allows comparison between very complex objects     a  1  b   hello   c    w    o    r    l    d    answer1   should be   answer2  true     equals  b   hello   a  1  c    w    d    o    r    answer1   should be   answer2  true    l       The upper example will return true  even tho the properties have a different ordering  One small detail to look out for  This code also checks for the same type of two variables  so  3  is not the same as 3

User · Answer

Lot s of good thoughts here  Here is my version of deep equal  I posted it on github and wrote some tests around it  It s hard to cover all the possible cases and sometimes it s unnecessary to do so    I covered NaN     NaN as well as circular dependencies   https   github com ryancat simple-deep-equal blob master index js

User · Answer

If you are working in AngularJS  the angular equals function will determine if two objects are equal  In Ember js use isEqual    angular equals - See the docs or source for more on this method  It does a deep compare on arrays too  Ember js isEqual - See the docs or source for more on this method  It does not do a deep compare on arrays     x000D   x000D  var purple      purple    drank     x000D  var drank      purple    drank     x000D   x000D  if angular equals purple  drank     x000D      document write  got dat    x000D    x000D   lt script src  https   ajax googleapis com ajax libs angularjs 1 4 5 angular min js  gt  lt  script gt  x000D   x000D   x000D

User · Answer

This is my version  It is using new Object keys feature that is introduced in ES5 and ideas tests from      and      x000D   x000D  function objectEquals x  y    x000D       use strict   x000D   x000D      if  x     null    x     undefined    y     null    y     undefined    return x     y    x000D         after this just checking type of one would be enough x000D      if  x constructor     y constructor    return false    x000D         if they are functions  they should exactly refer to same one  because of closures  x000D      if  x instanceof Function    return x     y    x000D         if they are regexps  they should exactly refer to same one  it is hard to better equality check on current ES  x000D      if  x instanceof RegExp    return x     y    x000D      if  x     y    x valueOf       y valueOf      return true    x000D      if  Array isArray x   amp  amp  x length     y length    return false    x000D   x000D         if they are dates  they must had equal valueOf x000D      if  x instanceof Date    return false    x000D   x000D         if they are strictly equal  they both need to be object at least x000D      if    x instanceof Object     return false    x000D      if    y instanceof Object     return false    x000D   x000D         recursive object equality check x000D      var p   Object keys x   x000D      return Object keys y  every function  i    return p indexOf i      -1      amp  amp  x000D          p every function  i    return objectEquals x i   y i        x000D    x000D   x000D   x000D                                                                  x000D      The borrowed tests  run them by clicking  Run code snippet  x000D                                                                  x000D  var printResult   function  x    x000D      if  x    document write   lt div style  color  green   gt Passed lt  div gt       x000D      else   document write   lt div style  color  red   gt Failed lt  div gt       x000D     x000D  var assert     isTrue  function  x    printResult x      isFalse  function  x    printResult  x       x000D  assert isTrue objectEquals null null    x000D  assert isFalse objectEquals null undefined    x000D  assert isFalse objectEquals  abc    abc     x000D  assert isFalse objectEquals  abc    123     x000D  var r    abc   x000D  assert isTrue objectEquals r  r    x000D   x000D  assert isTrue objectEquals  hi   hi     x000D  assert isTrue objectEquals 5 5    x000D  assert isFalse objectEquals 5 10    x000D   x000D  assert isTrue objectEquals          x000D  assert isTrue objectEquals  1 2   1 2     x000D  assert isFalse objectEquals  1 2   2 1     x000D  assert isFalse objectEquals  1 2   1 2 3     x000D   x000D  assert isTrue objectEquals          x000D  assert isTrue objectEquals  a 1 b 2   a 1 b 2     x000D  assert isTrue objectEquals  a 1 b 2   b 2 a 1     x000D  assert isFalse objectEquals  a 1 b 2   a 1 b 3     x000D   x000D  assert isTrue objectEquals  1  name  mhc  age 28   2  name  arb  age 26    1  name  mhc  age 28   2  name  arb  age 26      x000D  assert isFalse objectEquals  1  name  mhc  age 28   2  name  arb  age 26    1  name  mhc  age 28   2  name  arb  age 27      x000D   x000D  Object prototype equals   function  obj    return objectEquals this  obj      x000D  var assertFalse   assert isFalse  x000D      assertTrue   assert isTrue  x000D   x000D  assertFalse    equals null    x000D  assertFalse    equals undefined    x000D   x000D  assertTrue  hi  equals  hi     x000D  assertTrue new Number 5  equals 5    x000D  assertFalse new Number 5  equals 10    x000D  assertFalse new Number 1  equals  1     x000D   x000D  assertTrue    equals       x000D  assertTrue  1 2  equals  1 2     x000D  assertFalse  1 2  equals  2 1     x000D  assertFalse  1 2  equals  1 2 3     x000D  assertTrue new Date  2011-03-31   equals new Date  2011-03-31      x000D  assertFalse new Date  2011-03-31   equals new Date  1970-01-01      x000D   x000D  assertTrue    equals       x000D  assertTrue  a 1 b 2  equals  a 1 b 2     x000D  assertTrue  a 1 b 2  equals  b 2 a 1     x000D  assertFalse  a 1 b 2  equals  a 1 b 3     x000D   x000D  assertTrue  1  name  mhc  age 28   2  name  arb  age 26   equals  1  name  mhc  age 28   2  name  arb  age 26      x000D  assertFalse  1  name  mhc  age 28   2  name  arb  age 26   equals  1  name  mhc  age 28   2  name  arb  age 27      x000D   x000D  var a    a   text   b  0 1    x000D  var b    a   text   b  0 1    x000D  var c    a   text   b  0   x000D  var d    a   text   b  false   x000D  var e    a   text   b  1 0    x000D  var i     x000D      a   text   x000D      c    x000D          b   1  0  x000D        x000D     x000D  var j     x000D      a   text   x000D      c    x000D          b   1  0  x000D        x000D     x000D  var k    a   text   b  null   x000D  var l    a   text   b  undefined   x000D   x000D  assertTrue a equals b    x000D  assertFalse a equals c    x000D  assertFalse c equals d    x000D  assertFalse a equals e    x000D  assertTrue i equals j    x000D  assertFalse d equals k    x000D  assertFalse k equals l    x000D   x000D     from comments on stackoverflow post x000D  assert isFalse objectEquals  1  2  undefined    1  2     x000D  assert isFalse objectEquals  1  2  3     0  1  1  2  2  3      x000D  assert isFalse objectEquals new Date 1234   1234    x000D   x000D     no two different function is equal really  they capture their context variables x000D     so even if they have same toString    they won t have same functionality x000D  var func   function  x    return true     x000D  var func2   function  x    return true     x000D  assert isTrue objectEquals func  func    x000D  assert isFalse objectEquals func  func2    x000D  assert isTrue objectEquals   a    b  func        a    b  func        x000D  assert isFalse objectEquals   a    b  func        a    b  func2        x000D   x000D   x000D

User · Answer

you can use   isEqual obj1  obj2  from the underscore js library   Here is an example   var stooge    name   moe   luckyNumbers   13  27  34    var clone     name   moe   luckyNumbers   13  27  34    stooge    clone    gt  false   isEqual stooge  clone     gt  true   See the official documentation from here  http   underscorejs org  isEqual

User · Answer

I just wrote this  method just to be sure that  arrays  and  objects are both compared in a clear way   This should do the trick as well      public class Objects                  Checks whether a value is of type Object         param value the value             public static isObject    value  any   boolean   gt            return value     Object value   amp  amp  Object prototype toString call value        object Array                         Checks whether a value is of type Array         param value the value             public static isArray    value  any   boolean   gt            return Object prototype toString call value        object Array    amp  amp   Objects isObject value                        Check whether two values are equal             public static isEqual    objectA  any  objectB  any    gt               Objects         if  Objects isObject objectA   amp  amp   Objects isObject objectB                 return false                   else if   Objects isObject objectA   amp  amp  Objects isObject objectB                 return false                      Arrays         else if  Objects isArray objectA   amp  amp   Objects isArray objectB                 return false                   else if   Objects isArray objectA   amp  amp  Objects isArray objectB                 return false                      Primitives         else if   Objects isArray objectA   amp  amp   Objects isObject objectA                 return objectA     objectB                      Object or array         else               const compareObject    objectA  any  objectB  any   boolean   gt                    if  Object keys objectA  length     Object keys objectB  length  return false                  for  const propertyName of Object keys objectA                         const valueA   objectA propertyName                      const valueB   objectB propertyName                       if   Objects isEqual valueA  valueB                             return false                                                          return true                           const compareArray    arrayA  any    arrayB  any     boolean   gt                    if  arrayA length     arrayB length  return false                  for  const index in arrayA                        const valueA   arrayA index                      const valueB   arrayB index                       if   Objects isEqual valueA  valueB                             return false                                                          return true                           if  Objects isObject objectA                     return compareObject objectA  objectB                else                   return compareArray objectA  objectB

User · Answer

Assuming that the order of the properties in the object is not changed   JSON stringify   works for deep and non-deep both types of objects  not very sure of performance aspects    x000D   x000D  var object1     x000D    key   value  x000D     x000D   x000D  var object2     x000D    key   value  x000D     x000D   x000D  var object3     x000D    key   no value  x000D     x000D   x000D  console log  object1 and object2 are equal     JSON stringify object1      JSON stringify object2    x000D   x000D  console log  object2 and object3 are equal     JSON stringify object2      JSON stringify object3    x000D   x000D   x000D

User · Answer

A simple solution to this issue that many people don t realize is to sort the JSON strings  per character   This is also usually faster than the other solutions mentioned here   function areEqual obj1  obj2        var a   JSON stringify obj1   b   JSON stringify obj2       if   a  a           if   b  b           return  a split     sort   join        b split     sort   join           Another useful thing about this method is you can filter comparisons by passing a  replacer  function to the JSON stringify functions  https   developer mozilla org en-US docs Web JavaScript Reference Global Objects JSON stringify Example of using replacer parameter   The following will only compare all objects keys that are named  derp    function areEqual obj1  obj2  filter        var a   JSON stringify obj1  filter   b   JSON stringify obj2  filter       if   a  a           if   b  b           return  a split     sort   join        b split     sort   join         var equal   areEqual obj1  obj2  function key  value        return  key      derp     value   undefined

User · Answer

Sure  while we re at it I ll throw in my own reinvention of the wheel  I m proud of the number of spokes and materials used                                                                                       var equals   function   objectA  objectB         var result   false          keysA          keysB          Check if they are pointing at the same variable  If they are  no need to test further      if   objectA     objectB             return true                Check if they are the same type  If they are not  no need to test further      if   typeof objectA     typeof objectB             return false                Check what kind of variables they are to see what sort of comparison we should make      if   typeof objectA      object                 Check if they have the same constructor  so that we are comparing apples with apples          if   objectA constructor     objectA constructor                    If we are working with Arrays                if   objectA instanceof Array                        Check the arrays are the same length  If not  they cannot be the same                  if   objectA length     objectB length                            Compare each element  They must be identical  If not  the comparison stops immediately and returns false                      return objectA every                          function   element  i                                 return equals  element  objectB  i                                                                                            They are not the same length  and so are not identical                  else                       return false                                                 If we are working with RegExps                else if   objectA instanceof RegExp                        Return the results of a string comparison of the expression                  return   objectA toString       objectB toString                                   Else we are working with other types of objects                else                      Get the keys as arrays from both objects  This uses Object keys  so no old browsers here                  keysA   Object keys  objectA                     keysB   Object keys  objectB                        Check the key arrays are the same length  If not  they cannot be the same                  if   keysA length     keysB length                            Compare each property  They must be identical  If not  the comparison stops immediately and returns false                      return keysA every                          function   element                                 return equals  objectA  element    objectB  element                                                                                            They do not have the same number of keys  and so are not identical                  else                       return false                                                       They don t have the same constructor          else               return false                         If they are both functions  let us do a string comparison      else if   typeof objectA      function              return   objectA toString       objectB toString                   If a simple variable type  compare directly without coercion      else           return   objectA     objectB                  Return a default if nothing has already been returned      return result                                                                                         It returns false as quickly as possible  but of course for a large object where the difference is deeply nested it could be less effective  In my own scenario  good handling of nested arrays is important   Hope it helps someone needing this kind of  wheel

User · Answer

I m making the following assumptions with this function    You control the objects you are comparing and you only have primitive values  ie  not nested objects  functions  etc    Your browser has support for Object keys    This should be treated as a demonstration of a simple strategy          Checks the equality of two objects that contain primitive values   ie  no nested objects  functions  etc       param  Object  object1     param  Object  object2     param  Boolean   order matters  Affects the return value of unordered objects   ex   a 1  b 2  and  b 2  a 1        returns  Boolean      function isEqual  object1  object2  order matters         var keys1   Object keys object1           keys2   Object keys object2           i  key          Test 1  Same number of elements     if  keys1 length    keys2 length             return false                If order doesn t matter isEqual  a 2  b 1    b 1  a 2   should return true         keys1   Object keys  a 2  b 1       a   b           keys2   Object keys  b 1  a 2       b   a           This is why we are sorting keys1 and keys2      if   order matters             keys1 sort            keys2 sort                  Test 2  Same keys     for  i   0  i  lt  keys1 length  i               if  keys1 i     keys2 i                  return false                          Test 3  Values     for  i   0  i  lt  keys1 length  i               key   keys1 i           if  object1 key     object2 key                  return false                       return true

User · Answer

I d advise against hashing or serialization  as the JSON solution suggest    If you need to test if two objects are equal  then you need to define what equals means   It could be that all data members in both objects match  or it could be that must the memory locations match  meaning both variables reference the same object in memory   or may be that only one data member in each object must match   Recently I developed an object whose constructor creates a new id  starting from 1 and incrementing by 1  each time an instance is created   This object has an isEqual function that compares that id value with the id value of another object and returns true if they match   In that case I defined  equal  as meaning the the id values match   Given that each instance has a unique id this could be used to enforce the idea that matching objects also occupy the same memory location   Although that is not necessary

User · Answer

It s useful to consider two objects equal if they have all the same values for all properties and recursively for all nested objects and arrays   I also consider the following two objects equal   var a    p1  1   var b    p1  1  p2  undefined     Similarly  arrays can have  missing  elements and undefined elements   I would treat those the same as well   var c    1  2   var d    1  2  undefined     A function that implements this definition of equality   function isEqual a  b        if  a     b            return true             if  generalType a     generalType b             return false             if  a    b            return true             if  typeof a     object             return false                null           if  a instanceof Object    b instanceof Object            return false             if  a instanceof Date    b instanceof Date            if  a instanceof Date    b instanceof Date                a getTime      b getTime                  return false                       var allKeys      concat keys a   keys b        uniqueArray allKeys        for  var i   0  i  lt  allKeys length  i              var prop   allKeys i           if   isEqual a prop   b prop                  return false                      return true      Source code  including the helper functions  generalType and uniqueArray   Unit Test and Test Runner here

User · Answer

I use this comparable function to produce copies of my objects that are JSON comparable    x000D   x000D  var comparable   o   gt   typeof o     object      o   o   x000D    Object keys o  sort   reduce  c  key    gt   c key    comparable o key    c        x000D   x000D     Demo  x000D   x000D  var a     a  1  c  4  b   2  3   d    e   5   f  null      x000D  var b     b   2  3   c  4  d    f  null  e   5     a  1    x000D   x000D  console log JSON stringify comparable a     x000D  console log JSON stringify comparable b     x000D  console log JSON stringify comparable a      JSON stringify comparable b     x000D   lt div id  div  gt  lt  div gt  x000D   x000D   x000D    Comes in handy in tests  most test frameworks have an is function   E g   is JSON stringify comparable x    JSON stringify comparable y     x must match y      If a difference is caught  strings get logged  making differences spottable   x must match y got        a  1  b    0  2  1  3   c  7  d    e   5   f  null    expected   a  1  b    0  2  1  3   c  4  d    e   5   f  null

User · Answer

Though there are so many answers to this question already  My attempt is just to provide one more way of implementing this    x000D   x000D  const primitveDataTypes     number    boolean    string    undefined    x000D  const isDateOrRegExp    value    gt  value instanceof Date    value instanceof RegExp  x000D  const compare    first  second    gt    x000D      let agg   true  x000D      if typeof first     typeof second  amp  amp  primitveDataTypes indexOf typeof first      -1  amp  amp  first     second   x000D          agg    false  x000D        x000D         adding support for Date and RegExp  x000D      else if isDateOrRegExp first     isDateOrRegExp second    x000D          if first toString       second toString     x000D              agg   false  x000D            x000D        x000D      else   x000D          if Array isArray first   amp  amp  Array isArray second    x000D          if first length     second length   x000D               for let i   0  i  lt  first length  i     x000D                  if typeof first i       object   amp  amp  typeof second i       object    x000D                      agg   compare first i   second i    x000D                    x000D                  else if first i      second i    x000D                      agg   false  x000D                    x000D                x000D            else   x000D              agg   false  x000D            x000D        else   x000D          const firstKeys   Object keys first   x000D          const secondKeys   Object keys second   x000D          if firstKeys length     secondKeys length   x000D              agg   false  x000D            x000D          for let j   0   j  lt  firstKeys length  j     x000D              if firstKeys j      secondKeys j    x000D                  agg   false  x000D                x000D              if first firstKeys j    amp  amp  second secondKeys j    amp  amp  typeof first firstKeys j        object   amp  amp  typeof second secondKeys j        object    x000D                  agg   compare first firstKeys j    second secondKeys j     x000D                  x000D               else if first firstKeys j       second secondKeys j     x000D                  agg   false  x000D                  x000D            x000D        x000D        x000D      return agg  x000D    x000D   x000D   x000D  console log  result   compare  a  1  b    c   4   d 5    e 6     r  null    a  1  b    c   4   d 5    e 6     r   ffd         returns false  x000D   x000D   x000D

User · Answer

Depends on what you mean by equality  And therefore it is up to you  as the developer of the classes  to define their equality   There s one case used sometimes  where two instances are considered  equal  if they point to the same location in memory  but that is not always what you want  For instance  if I have a Person class  I might want to consider two Person objects  equal  if they have the same Last Name  First Name  and Social Security Number  even if they point to different locations in memory    On the other hand  we can t simply say that two objects are equal if the value of each of their members is the same  since  sometimes  you don t want that  In other words  for each class  it s up to the class developer to define what members make up the objects  identity  and develop a proper equality operator  be it via overloading the    operator or an Equals method    Saying that two objects are equal if they have the same hash is one way out  However you then have to wonder how the hash is calculated for each instance  Going back to the Person example above  we could use this system if the hash was calculated by looking at the values of the First Name  Last Name  and Social Security Number fields  On top of that  we are then relying on the quality of the hashing method  that s a huge topic on its own  but suffice it to say that not all hashes are created equal  and bad hashing methods can lead to more collisions  which in this case would return false matches

User · Answer

var object1    name   humza    gender    male   age  23  var object2    name   humza    gender    male   age  23  var result   Object keys object1  every  key    gt   object1 key      object2 key     Result will be true if object1 has same values on object2

User · Answer

Some of the following solutions have problems with performance  functionality and style    They are not thought through enough  and some of them fail for different cases  I tried to address this problem in my own solution  and I would really much appreciate your feedback   http   stamat wordpress com javascript-object-comparison     Returns the object s class  Array  Date  RegExp  Object are of interest to us var getClass   function val        return Object prototype toString call val           match     object s          1         Defines the type of the value  extended typeof var whatis   function val         if  val     undefined          return  undefined       if  val     null          return  null        var type   typeof val       if  type      object           type   getClass val  toLowerCase         if  type      number             if  val toString   indexOf       gt  0              return  float           else         return  integer              return type         var compareObjects   function a  b        if  a     b          return true      for  var i in a            if  b hasOwnProperty i                 if   equal a i  b i    return false            else               return false                       for  var i in b            if   a hasOwnProperty i                 return false                      return true      var compareArrays   function a  b        if  a     b          return true      if  a length     b length          return false      for  var i   0  i  lt  a length  i             if  equal a i   b i    return false             return true      var  equal        equal array   compareArrays   equal object   compareObjects   equal date   function a  b        return a getTime       b getTime        equal regexp   function a  b        return a toString       b toString           uncoment to support function as string compare      equal fucntion     equal regexp           Are two values equal  deep compare for objects and arrays      param a  any      param b  any      return  boolean  Are equal      var equal   function a  b        if  a     b            var atype   whatis a   btype   whatis b            if  atype     btype              return  equal hasOwnProperty atype     equal atype  a  b    a  b           return false             return true

User · Answer

A simple solution to this issue that many people don t realize is to sort the JSON strings  per character   This is also usually faster than the other solutions mentioned here   function areEqual obj1  obj2        var a   JSON stringify obj1   b   JSON stringify obj2       if   a  a           if   b  b           return  a split     sort   join        b split     sort   join           Another useful thing about this method is you can filter comparisons by passing a  replacer  function to the JSON stringify functions  https   developer mozilla org en-US docs Web JavaScript Reference Global Objects JSON stringify Example of using replacer parameter   The following will only compare all objects keys that are named  derp    function areEqual obj1  obj2  filter        var a   JSON stringify obj1  filter   b   JSON stringify obj2  filter       if   a  a           if   b  b           return  a split     sort   join        b split     sort   join         var equal   areEqual obj1  obj2  function key  value        return  key      derp     value   undefined

User · Answer

This question has more than 30 answers already   I am going to summarize and explain them  with a  quot my father quot  analogy  and add my suggested solution  You have 4 1 classes of solutions   1  Use a hacky incomplete quick one-liner Good if you are in a rush and 99  correctness works  Examples of this is  JSON stringify   suggested by Pratik Bhalodiya  or JSON encode by Joel Anair  or  toString    or other methods that transform your objects into a String and then compare the two Strings using     character by character  The drawback  however  is that there is no globally standard unique representation of an Object in String   e g    a  5  b  8  and  b  8 and a  5   are equal   Pros  Fast  quick  Cons  Hopefully works   It will not work if the environment browser engine memorizes the ordering for objects  e g  Chrome V8  and the order of the keys are different  Thanks to Eksapsy   So  not guaranteed at all   Performance wouldn t be great either in large objects   My Father Analogy When I am talking about my father   quot my tall handsome father quot  and  quot my handsome tall father quot  are the same person   But the two strings are not the same  Note that there is actually a correct  standard way  order of adjectives in English grammar  which says it should be a  quot handsome tall man  quot  but you are risking your competency if you blindly assume Javascript engine of iOS 8 Safari is also abiding the same grammar  blindly   WelcomeToJavascriptNonStandards  2  Write your own DIY recursive function Good if you are learning  Examples are atmin s solution  The biggest disadvantage is you will definitely miss some edge cases   Have you considered a self-reference in object values   Have you considered NaN  Have you considered two objects that have the same ownProperties but different prototypical parents  I would only encourage people to do this if they are practicing and the code is not going to go in production   That s the only case that reinventing the wheel has justifications   Pros  Learning opportunity  Cons  Not reliable   Takes time and concerns   My Father Analogy It s like assuming if my dad s name is  quot John Smith quot  and his birthday is  quot 1 1 1970 quot   then anyone whose name is  quot John Smith quot  and is born on  quot 1 1 1970 quot  is my father  That s usually the case  but what if there are two  quot John Smith quot s born on that day   If you think you will consider their height  then that s increasing the accuracy but still not a perfect comparison  2 1 You limited scope DIY comparator Rather than going on a wild chase of checking all the properties recursively  one might consider checking only  quot a limited quot  number of properties   For instance  if the objects are Users  you can compare their emailAddress field  It s still not a perfect one  but the benefits over solution  2 are   It s predictable  and it s less likely to crash  You are driving the  quot definition quot  of equality  rather than relying on a wild form and shape of the Object and its prototype and nested properties    3  Use a library version of equal function Good if you need a production-level quality  and you cannot change the design of the system  Examples are   equal of lodash  already in coolaj86 s answer or Angular s or Ember s as mentioned in Tony Harvey s answer or Node s by Rafael Xavier   Pros  It s what everyone else does  Cons  External dependency  which can cost you extra memory CPU Security concerns  even a little bit   Also  can still miss some edge cases  e g  whether two objects having same ownProperties but different prototypical parents should be considered the same or not   Finally  you might be unintentionally band-aiding an underlying design problem with this  just saying   My Father Analogy It s like paying an agency to find my biological father  based on his phone  name  address  etc  It s gonna cost more  and it s probably more accurate than myself running the background check  but doesn t cover edge cases like when my father is immigrant asylum and his birthday is unknown   4  Use an IDentifier in the Object Good if you  still  can change the design of the system  objects you are dealing with  and you want your code to last long  It s not applicable in all cases  and might not be very performant   However  it s a very reliable solution  if you can make it  The solution is  every object in the system will have a unique identifier along with all the other properties   The uniqueness of the identifier will be guaranteed at the time of generation   And you will use this ID  also known as UUID GUID -- Globally Universally Unique Identifier  when it comes to comparing two objects   i e  They are equal if and only if these IDs are equal  The IDs can be simple auto incremental numbers  or a string generated via a library  advised  or a piece of code   All you need to do is make sure it s always unique  which in case of auto incremental it can be built-in  or in case of UUID  can be checked will all existing values  e g  MySQL s UNIQUE column attribute  or simply  if coming from a library  be relied upon giving the extremely low likelihood of a collision  Note that you also need to store the ID with the object at all times  to guarantee its uniqueness   and computing it in real-time might not be the best approach   Pros  Reliable  efficient  not dirty  modern  Cons  Needs extra space   Might need a redesign of the system   My Father Analogy It s like known my father s Social Security Number is 911-345-9283  so anyone who has this SSN is my father  and anyone who claims to be my father must have this SSN   Conclusion I personally prefer solution  4  ID  over them all for accuracy and reliability   If it s not possible I d go with  2 1 for predictability  and then  3   If neither is possible   2 and finally  1

User · Answer

function isEqual obj1  obj2       type1   typeof obj1       type2   typeof obj2       if type1   type2           switch  type1               case  object   return JSON stringify obj1    JSON stringify obj2               case  function   return eval obj1  toString     eval obj2  toString                default  return obj1  obj2                      return false     have not tried but should work

User · Answer

Just wanted to contribute my version of objects comparison utilizing some es6 features  It doesn t take an order into account  After converting all if else s to ternary I ve came with following   function areEqual obj1  obj2         return Object keys obj1  every key   gt                 return obj2 hasOwnProperty key                    typeof obj1 key       object                        areEqual obj1 key   obj2 key                     obj1 key      obj2 key                    false

User · Answer

I ve written a small library that runs on Node js and the browser called compare js  It offers the usual comparison operators  such as                 lt    lt   and identity on all data types of JavaScript   E g   you can use  cmp eq obj1  obj2     and this will check for equality  using a deep-equal approach   Otherwise  if you do  cmp id obj1  obj2     it will compare by reference  hence check for identity  You can also use  lt  and   on objects  which mean subset and superset   compare js is covered by nearly 700 unit tests  hence it should hopefully not have too many bugs  -    You can find it on https   github com goloroden compare js for free  it is open-sourced under the MIT license

User · Answer

Just wanted to contribute my version of objects comparison utilizing some es6 features  It doesn t take an order into account  After converting all if else s to ternary I ve came with following   function areEqual obj1  obj2         return Object keys obj1  every key   gt                 return obj2 hasOwnProperty key                    typeof obj1 key       object                        areEqual obj1 key   obj2 key                     obj1 key      obj2 key                    false

User · Answer

A quick  hack  to tell if two objects are similar  is to use their toString   methods  If you re checking objects A and B  make sure A and B have meaningful toString   methods and check that the strings they return are the same   This isn t a panacea  but it can be useful sometimes in the right situations

User · Answer

If you have a deep copy function handy  you can use the following trick to still use JSON stringify while matching the order of properties   function equals obj1  obj2        function  equals obj1  obj2            return JSON stringify obj1                  JSON stringify   extend true      obj1  obj2              return  equals obj1  obj2   amp  amp   equals obj2  obj1       Demo  http   jsfiddle net CU3vb 3   Rationale   Since the properties of obj1 are copied to the clone one by one  their order in the clone will be preserved  And when the properties of obj2 are copied to the clone  since properties already existing in obj1 will simply be overwritten  their orders in the clone will be preserved

User · Answer

Here s a pretty clean CoffeeScript version of how you could do this   Object  equals    other  - gt    typeOf   Object  toString    return false if typeOf call this  isnt typeOf call other    return  this    other  unless typeOf call other  is   object Object   or                                 typeOf call other  is   object Array       return false unless this key  equals other key   for key  value of this    return false if typeof this key  is  undefined   for key of other    true   Here are the tests     describe  equals   - gt       it  should consider two numbers to be equal   - gt        assert 5 equals 5       it  should consider two empty objects to be equal   - gt        assert    equals          it  should consider two objects with one key to be equal   - gt        assert  a   banana   equals  a   banana        it  should consider two objects with keys in different orders to be equal   - gt        assert  a   banana   kendall   garrus   equals  kendall   garrus   a   banana        it  should consider two objects with nested objects to be equal   - gt        assert  a   fruit   banana    equals  a   fruit   banana         it  should consider two objects with nested objects that are jumbled to be equal   - gt        assert  a   a   banana   kendall   garrus    equals  a   kendall   garrus   a   banana         it  should consider two objects with arrays as values to be equal   - gt        assert  a    apple    banana    equals  a    apple    banana           it  should not consider an object to be equal to null   - gt        assert    a   banana   equals null       it  should not consider two objects with different keys to be equal   - gt        assert    a   banana   equals          it  should not consider two objects with different values to be equal   - gt        assert    a   banana   equals  a   grapefruit

User · Answer

I just wrote this  method just to be sure that  arrays  and  objects are both compared in a clear way   This should do the trick as well      public class Objects                  Checks whether a value is of type Object         param value the value             public static isObject    value  any   boolean   gt            return value     Object value   amp  amp  Object prototype toString call value        object Array                         Checks whether a value is of type Array         param value the value             public static isArray    value  any   boolean   gt            return Object prototype toString call value        object Array    amp  amp   Objects isObject value                        Check whether two values are equal             public static isEqual    objectA  any  objectB  any    gt               Objects         if  Objects isObject objectA   amp  amp   Objects isObject objectB                 return false                   else if   Objects isObject objectA   amp  amp  Objects isObject objectB                 return false                      Arrays         else if  Objects isArray objectA   amp  amp   Objects isArray objectB                 return false                   else if   Objects isArray objectA   amp  amp  Objects isArray objectB                 return false                      Primitives         else if   Objects isArray objectA   amp  amp   Objects isObject objectA                 return objectA     objectB                      Object or array         else               const compareObject    objectA  any  objectB  any   boolean   gt                    if  Object keys objectA  length     Object keys objectB  length  return false                  for  const propertyName of Object keys objectA                         const valueA   objectA propertyName                      const valueB   objectB propertyName                       if   Objects isEqual valueA  valueB                             return false                                                          return true                           const compareArray    arrayA  any    arrayB  any     boolean   gt                    if  arrayA length     arrayB length  return false                  for  const index in arrayA                        const valueA   arrayA index                      const valueB   arrayB index                       if   Objects isEqual valueA  valueB                             return false                                                          return true                           if  Objects isObject objectA                     return compareObject objectA  objectB                else                   return compareArray objectA  objectB

User · Answer

The default equality operator in JavaScript for Objects yields true when they refer to the same location in memory   var x       var y       var z   x   x     y       gt  false x     z       gt  true   If you require a different equality operator you ll need to add an equals other  method  or something like it to your classes and the specifics of your problem domain will determine what exactly that means   Here s a playing card example   function Card rank  suit      this rank   rank    this suit   suit    this equals   function other         return other rank    this rank  amp  amp  other suit    this suit          var queenOfClubs   new Card 12   C    var kingOfSpades   new Card 13   S     queenOfClubs equals kingOfSpades        gt  false kingOfSpades equals new Card 13   S          gt  true

User · Answer

In Node js  you can use its native require  assert   deepStrictEqual  More info   http   nodejs org api assert html  For example   var assert   require  assert    assert deepStrictEqual  a 1  b 2    a 1  b 3       will throw AssertionError   Another example that returns true   false instead of returning errors   var assert   require  assert     function deepEqual a  b        try         assert deepEqual a  b         catch  error          if  error name      AssertionError             return false                throw error            return true

User · Answer

The short answer  The simple answer is  No  there is no generic means to determine that an object is equal to another in the sense you mean  The exception is when you are strictly thinking of an object being typeless   The long answer  The concept is that of an Equals method that compares two different instances of an object to indicate whether they are equal at a value level  However  it is up to the specific type to define how an Equals method should be implemented  An iterative comparison of attributes that have primitive values may not be enough  there may well be attributes which are not to be considered part of the object value  For example    function MyClass a  b          var c       this getCLazy   function              if  c     undefined  c   a   b    imagine   is really expensive          return c               In this above case  c is not really important to determine whether any two instances of MyClass are equal  only a and b are important  In some cases c might vary between instances and yet not be significant during comparison    Note this issue applies when members may themselves also be instances of a type and these each would all be required to have a means of determining equality   Further complicating things is that in JavaScript the distinction between data and method is blurred   An object may reference a method that is to be called as an event handler  and this would likely not be considered part of its  value state   Whereas another object may well be assigned a function that performs an important calculation and thereby makes this instance different from others simply because it references a different function   What about an object that has one of its existing prototype methods overridden by another function  Could it still be considered equal to another instance that it otherwise identical  That question can only be answered in each specific case for each type   As stated earlier  the exception would be a strictly typeless object  In which case the only sensible choice is an iterative and recursive comparison of each member  Even then one has to ask what is the  value  of a function

User · Answer

A quick  hack  to tell if two objects are similar  is to use their toString   methods  If you re checking objects A and B  make sure A and B have meaningful toString   methods and check that the strings they return are the same   This isn t a panacea  but it can be useful sometimes in the right situations

User · Answer

In Node js  you can use its native require  assert   deepStrictEqual  More info   http   nodejs org api assert html  For example   var assert   require  assert    assert deepStrictEqual  a 1  b 2    a 1  b 3       will throw AssertionError   Another example that returns true   false instead of returning errors   var assert   require  assert     function deepEqual a  b        try         assert deepEqual a  b         catch  error          if  error name      AssertionError             return false                throw error            return true

User · Answer

Object equality check JSON stringify array1 sort        JSON stringify array2 sort     The above test also works with arrays of objects in which case use a sort function as documented in http   www w3schools com jsref jsref sort asp  Might suffice for small arrays with flat JSON schemas

User · Answer

x000D   x000D  const obj       name   Carl     age  15   const obj2       name   Carl     age  15      const compareObj    objects    gt      const res    objects map  item    gt        return Object entries item  flat   join          return res every  a    gt        return a     res 0          console log compareObj  obj obj2    x000D   x000D   x000D

User · Answer

I m not a Javascript expert  but here is one simple attempt to solve it  I check for three things    Is it an object and also that it is not null because typeof null is object  If the property count of the two objects is the same  If not they are not equal  Loop through properties of one and check if corresponding property has same value in second object     x000D   x000D  function deepEqual  first  second    x000D       Not equal if either is not an object or is null  x000D    if   isObject first      isObject second    return false  x000D   x000D       If properties count is different x000D    if  keys first  length    keys second  length  return false  x000D   x000D       Return false if any property value is different  x000D    for prop in first   x000D      if  first prop     second prop   return false  x000D      x000D    return true  x000D    x000D   x000D     Checks if argument is an object and is not null x000D  function isObject obj    x000D    return  typeof obj      object   amp  amp  obj    null   x000D    x000D   x000D     returns arrays of object keys x000D  function keys  obj    x000D    result       x000D    for var key in obj   x000D      result push key   x000D      x000D    return result  x000D    x000D   x000D     Some test code x000D  obj1     x000D    name   Singh   x000D    age  20 x000D    x000D   x000D  obj2     x000D    age  20  x000D    name   Singh  x000D    x000D   x000D  obj3     x000D    name   Kaur   x000D    age  19 x000D    x000D   x000D  console log deepEqual obj1  obj2    x000D  console log deepEqual obj1  obj3    x000D   x000D   x000D

User · Answer

If you have a deep copy function handy  you can use the following trick to still use JSON stringify while matching the order of properties   function equals obj1  obj2        function  equals obj1  obj2            return JSON stringify obj1                  JSON stringify   extend true      obj1  obj2              return  equals obj1  obj2   amp  amp   equals obj2  obj1       Demo  http   jsfiddle net CU3vb 3   Rationale   Since the properties of obj1 are copied to the clone one by one  their order in the clone will be preserved  And when the properties of obj2 are copied to the clone  since properties already existing in obj1 will simply be overwritten  their orders in the clone will be preserved

User · Answer

I use this comparable function to produce copies of my objects that are JSON comparable    x000D   x000D  var comparable   o   gt   typeof o     object      o   o   x000D    Object keys o  sort   reduce  c  key    gt   c key    comparable o key    c        x000D   x000D     Demo  x000D   x000D  var a     a  1  c  4  b   2  3   d    e   5   f  null      x000D  var b     b   2  3   c  4  d    f  null  e   5     a  1    x000D   x000D  console log JSON stringify comparable a     x000D  console log JSON stringify comparable b     x000D  console log JSON stringify comparable a      JSON stringify comparable b     x000D   lt div id  div  gt  lt  div gt  x000D   x000D   x000D    Comes in handy in tests  most test frameworks have an is function   E g   is JSON stringify comparable x    JSON stringify comparable y     x must match y      If a difference is caught  strings get logged  making differences spottable   x must match y got        a  1  b    0  2  1  3   c  7  d    e   5   f  null    expected   a  1  b    0  2  1  3   c  4  d    e   5   f  null

User · Answer

Some of the following solutions have problems with performance  functionality and style    They are not thought through enough  and some of them fail for different cases  I tried to address this problem in my own solution  and I would really much appreciate your feedback   http   stamat wordpress com javascript-object-comparison     Returns the object s class  Array  Date  RegExp  Object are of interest to us var getClass   function val        return Object prototype toString call val           match     object s          1         Defines the type of the value  extended typeof var whatis   function val         if  val     undefined          return  undefined       if  val     null          return  null        var type   typeof val       if  type      object           type   getClass val  toLowerCase         if  type      number             if  val toString   indexOf       gt  0              return  float           else         return  integer              return type         var compareObjects   function a  b        if  a     b          return true      for  var i in a            if  b hasOwnProperty i                 if   equal a i  b i    return false            else               return false                       for  var i in b            if   a hasOwnProperty i                 return false                      return true      var compareArrays   function a  b        if  a     b          return true      if  a length     b length          return false      for  var i   0  i  lt  a length  i             if  equal a i   b i    return false             return true      var  equal        equal array   compareArrays   equal object   compareObjects   equal date   function a  b        return a getTime       b getTime        equal regexp   function a  b        return a toString       b toString           uncoment to support function as string compare      equal fucntion     equal regexp           Are two values equal  deep compare for objects and arrays      param a  any      param b  any      return  boolean  Are equal      var equal   function a  b        if  a     b            var atype   whatis a   btype   whatis b            if  atype     btype              return  equal hasOwnProperty atype     equal atype  a  b    a  b           return false             return true

User · Answer

For those of you using Node  there is a convenient method called isDeepStrictEqual on the nativeutil library that can achieve this  const util   require  util     const obj1       foo   quot bar quot     baz   1  2      const obj2       foo   quot bar quot     baz   1  2       obj1    obj2    false util isDeepStrictEqual obj1  obj2     true   https   nodejs org api util html util util isdeepstrictequal val1 val2

User · Answer

I see spaghetti code answers  Without using any third party libs  this is very easy   Firstly sort the two objects by key their key names   let objectOne     hey  you   let objectTwo     you  hey       If you really wanted you could make this recursive for deep sort  const sortObjectByKeyname    objectToSort    gt        return Object keys objectToSort  sort   reduce  r  k    gt   r k    objectToSort k   r           let objectOne   sortObjectByKeyname objectOne  let objectTwo   sortObjectByKeyname objectTwo    Then simply use a string to compare them   JSON stringify objectOne      JSON stringify objectTwo

User · Answer

Are you trying to test if two objects are the equal  ie  their properties are equal   If this is the case  you ll probably have noticed this situation   var a     foo    bar     var b     foo    bar     alert  a    b    Equal     Not equal        Not equal    you might have to do something like this   function objectEquals obj1  obj2        for  var i in obj1            if  obj1 hasOwnProperty i                 if   obj2 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      for  var i in obj2            if  obj2 hasOwnProperty i                 if   obj1 hasOwnProperty i   return false              if  obj1 i     obj2 i   return false                      return true      Obviously that function could do with quite a bit of optimisation  and the ability to do deep checking  to handle nested objects  var a     foo     fu    bar       but you get the idea   As FOR pointed out  you might have to adapt this for your own purposes  eg  different classes may have different definitions of  equal   If you re just working with plain objects  the above may suffice  otherwise a custom MyClass equals   function may be the way to go

User · Answer

For comparing keys for simple key value pairs object instances  I use   function compareKeys r1  r2        var nloops   0  score   0      for k1 in r1            for k2 in r2                nloops                if k1    k2                  score                         return nloops     score   score        Once keys are compared  a simple additional for  in loop is enough   Complexity is O N N  with N is the number of keys    I hope guess objects I define won t hold more than 1000 properties

User · Answer

The default equality operator in JavaScript for Objects yields true when they refer to the same location in memory   var x       var y       var z   x   x     y       gt  false x     z       gt  true   If you require a different equality operator you ll need to add an equals other  method  or something like it to your classes and the specifics of your problem domain will determine what exactly that means   Here s a playing card example   function Card rank  suit      this rank   rank    this suit   suit    this equals   function other         return other rank    this rank  amp  amp  other suit    this suit          var queenOfClubs   new Card 12   C    var kingOfSpades   new Card 13   S     queenOfClubs equals kingOfSpades        gt  false kingOfSpades equals new Card 13   S          gt  true

User · Answer

const one  name  mohit    age 30     const two   name  mohit  age 30   const two   age 30 name  mohit     function isEquivalent a  b       Create arrays of property names var aProps   Object getOwnPropertyNames a   var bProps   Object getOwnPropertyNames b         If number of properties is different     objects are not equivalent if  aProps length    bProps length        return false     for  var i   0  i  lt  aProps length  i          var propName   aProps i           If values of same property are not equal         objects are not equivalent     if  a propName      b propName             return false              If we made it this far  objects    are considered equivalent return true     console log isEquivalent one two

User · Answer

One additional option  is use equals of Ramda library  const c    a  1  b  2   const d    b  2  a  1   R equals c  d       gt  true

User · Answer

Pulling out from my personal library  which i use for my work repeatedly  The following function is a lenient recursive deep equal  which does not check   Class equality Inherited values Values strict equality   I mainly use this to check if i get equal replies against various API implementation  Where implementation difference  like string vs number  and additional null values  can occur    Its implementation is quite straightforward and short  if all the comments is stripped off    x000D   x000D      Recursively check if both objects are equal in value x000D      x000D      This function is designed to use multiple methods from most probable  x000D       and in most cases  valid  to the more regid and complex method  x000D      x000D      One of the main principles behind the various check is that while x000D      some of the simpler checks such as    or JSON may cause false negatives  x000D      they do not cause false positives  As such they can be safely run first  x000D      x000D         Important Note  x000D      as this function is designed for simplified deep equal checks it is not designed x000D      for the following x000D      x000D      - Class equality   ClassA   a   1  maybe valid to  ClassB   b   1  x000D      - Inherited values  this actually ignores them x000D      - Values being strictly equal   1  is equal to 1  see the basic equality check on this  x000D      - Performance across all cases  This is designed for high performance on the x000D        most probable cases of      JSON equality  Consider bench testing  if you have x000D        more  complex  requirments x000D      x000D       param  objA   First object to compare x000D       param  objB   2nd object to compare x000D       param         Any other objects to compare x000D      x000D       returns true if all equals  or false if invalid x000D      x000D       license Copyright by eugene picoded com  2012  x000D               Licensed under the MIT license  http   opensource org licenses MIT x000D      x000D  function simpleRecusiveDeepEqual objA  objB    x000D      Multiple comparision check x000D     -------------------------------------------- x000D   var args   Array prototype slice call arguments   x000D   if args length  gt  2    x000D    for var a 1  a lt args length    a    x000D     if  simpleRecusiveDeepEqual args a-1   args a      x000D      return false  x000D       x000D      x000D    return true  x000D     else if args length  lt  2    x000D    throw  simpleRecusiveDeepEqual  requires atleast 2 arguments   x000D     x000D    x000D      basic equality check  x000D     -------------------------------------------- x000D      if this succed the 2 basic values is equal  x000D      such as numbers and string  x000D      x000D      or its actually the same object pointer  Bam x000D      x000D      Note that if string and number strictly equal is required x000D      change the equality from     to     x000D      x000D   if objA    objB    x000D    return true  x000D     x000D    x000D      If a value is a bsic type  and failed above  This fails x000D   var basicTypes     boolean    number    string    x000D   if  basicTypes indexOf typeof objA   gt   0    basicTypes indexOf typeof objB   gt   0     x000D    return false  x000D     x000D    x000D      JSON equality check  x000D     -------------------------------------------- x000D      this can fail  if the JSON stringify the objects in the wrong order x000D      for example the following may fail  due to different string order  x000D      x000D      JSON stringify   a 1  b 2       JSON stringify   b 2  a 1    x000D      x000D   if JSON stringify objA     JSON stringify objB     x000D    return true  x000D     x000D    x000D      Array equality check x000D     -------------------------------------------- x000D      This is performed prior to iteration check  x000D      Without this check the following would have been considered valid x000D      x000D      simpleRecusiveDeepEqual    0 1963     1963     x000D      x000D      Note that u may remove this segment if this is what is intended x000D      x000D   if  Array isArray objA      x000D      objA is array  objB is not an array x000D    if   Array isArray objB      x000D     return false  x000D      x000D     else if  Array isArray objB      x000D      objA is not array  objB is an array x000D    return false  x000D     x000D    x000D      Nested values iteration x000D     -------------------------------------------- x000D      Scan and iterate all the nested values  and check for non equal values recusively x000D      x000D      Note that this does not check against null equality  remove the various     null  x000D      if this is required x000D    x000D   var i    reuse var to iterate x000D    x000D      Check objA values against objB x000D   for  i in objA    x000D      Protect against inherited properties x000D    if objA hasOwnProperty i     x000D     if objB hasOwnProperty i     x000D         Check if deep equal is valid x000D      if  simpleRecusiveDeepEqual  objA i   objB i       x000D       return false  x000D        x000D       else if objA i     null    x000D        ignore null values in objA  that objB does not have x000D        else fails x000D      return false  x000D       x000D      x000D     x000D    x000D      Check if objB has additional values  that objA do not  fail if so x000D   for  i in objB    x000D    if objB hasOwnProperty i     x000D     if objB i     null  amp  amp   objA hasOwnProperty i     x000D        ignore null values in objB  that objA does not have x000D        else fails x000D      return false  x000D       x000D      x000D     x000D    x000D      End of all checks x000D     -------------------------------------------- x000D      By reaching here  all iteration scans have been done  x000D      and should have returned false if it failed x000D   return true  x000D    x000D   x000D     Sanity checking of simpleRecusiveDeepEqual x000D   function     x000D   if  x000D       Basic checks x000D     simpleRecusiveDeepEqual            x000D     simpleRecusiveDeepEqual            x000D     simpleRecusiveDeepEqual   a      a       x000D       Not strict checks x000D     simpleRecusiveDeepEqual  1   1     x000D       Multiple objects check x000D     simpleRecusiveDeepEqual    a  1 2       a  1 2       a  1 2         x000D       Ensure distinction between array and object  the following should fail  x000D    simpleRecusiveDeepEqual   1963     0 1963        x000D       Null strict checks x000D    simpleRecusiveDeepEqual  0  null      x000D    simpleRecusiveDeepEqual      null      x000D       Last  false  exists to make the various check above easy to comment in out x000D    false x000D       x000D    alert  FATAL ERROR  simpleRecusiveDeepEqual failed basic checks    x000D     else    x000D      added this last line  for SO snippet alert on success x000D    alert  simpleRecusiveDeepEqual  Passed all checks  Yays     x000D     x000D        x000D   x000D   x000D

User · Answer

I know this is a bit old  but I would like to add a solution that I came up with for this problem  I had an object  and I wanted to know when its data changed   something similar to Object observe  and what I did was   function checkObjects obj obj2      var values          var keys          keys   Object keys obj      keys forEach function key         values push key             var values2          var keys2          keys2   Object keys obj2      keys2 forEach function key         values2 push key             return  values    values2  amp  amp  keys    keys2      This here can be duplicated and create an other set of arrays to compare the values and keys  It is very simple because they are now arrays and will return false if objects have different sizes

User · Answer

My version  which includes the chain of where the difference is found  and what the difference is   function DeepObjectCompare O1  O2        try           DOC Val O1  O2    O1- gt O2   O1  O2            return DOC Val O2  O1    O2- gt O1   O1  O2          catch e            console log e Chain           throw e           function DOC Error Reason  Chain  Val1  Val2        this Reason Reason      this Chain Chain      this Val1 Val1      this Val2 Val2     function DOC Val Val1  Val2  Chain        function DoThrow Reason  NewChain    throw new DOC Error Reason  NewChain   undefined   NewChain   Chain  Val1  Val2           if typeof Val1    typeof Val2           return DoThrow  Type Mismatch        if Val1   null    Val1   undefined          return Val1   Val2   DoThrow  Null undefined mismatch     true      if Val1 constructor   Val2 constructor          return DoThrow  Constructor mismatch        switch typeof Val1                 case  object               for var m in Val1                                if  Val1 hasOwnProperty m                       continue                  var CurChain Chain concat  m                    if  Val2 hasOwnProperty m                       return DoThrow  Val2 missing property   CurChain                   DOC Val Val1 m   Val2 m   CurChain                             return true          case  number               if Number isNaN Val1                   return  Number isNaN Val2    DoThrow  NaN mismatch     true          case  string           case  boolean               return Val1   Val2   DoThrow  Value mismatch     true          case  function               if Val1 prototype   Val2 prototype                  return DoThrow  Prototype mismatch                if Val1   Val2                  return DoThrow  Function mismatch                return true          default              return DoThrow  Val1 is unknown type

[javascript] How to determine equality for two JavaScript objects?

Examples related to javascript

Examples related to object

Examples related to equals

Examples related to hashcode