nv/objectdiff.js

Compares JavaScript objects

objectDiff

objectdiff on npm

objectDiff.diff(objectA, objectB)

objectDiff.diff({x: 1}, {x: 2})
-> {
  changed: "object change",
  value: {
    x: {
      changed: "primitive change",
      removed: 1,
      added: 2
    }
  }
}

objectDiff.diff({z: {x: 1}}, {z: {y: 2}})
-> {
  changed: "object change",
  value: {
    z: {
      changed: "object change",
      value: {
        x: {
          changed: "removed",
          value: 1
        },
        y: {
          changed: "added",
          value: 2
        }
      }
    }
  }
}

objectDiff.diffOwnProperties(objectA, objectB)

Same as objectDiff.diff, but compares only objects' own properties

function A(){}
A.prototype.x = 1
objectDiff.diff({x: 1}, new A)
-> {changed: "equal", value: {x: 1}}

objectDiff.diffOwnProperties({x: 1}, new A)
-> {changed: "object change", value: {x: {changed: "removed", value: 1}}}

objectDiff.convertToXMLString(diffObject)

Used on the demo page.

Jasmine integration

objectDiff provides toEqualProperties and toEqualOwnProperties matchers for Jasmine. See example spec.

objectdiff.js's Issues

Use JSONPatch format

http://jsonpatch.com/

indent the highlighting in the demo

Indenting the highlighting in the demo would make it easier to spot the level in the tree that the difference occurs at. For example, in the example the a/b (using jsonpointer) diff is one level deeper than the other diffs. Indenting the highlight block two and four characters could help show that.

NPM version outdated

It looks like the version on NPM is outdated:

https://npmjs.org/package/objectdiff

Maybe you can push an update? If you do so, could you commit your package.json to github so we can compare the versions numbers (and do other nifty things as well)?

(I had to diff your diff code to see if it diffs to different diffs.. :)

Change Date Object Not Detected

This is a great tool. Unfortunately, I found one issue. When an object node is a date, the code fails to detect an update to the date objec nodet.

Description of the algorithm's behavior

It would be super helpful if you could describe the behavior of the algorithm in the docs. I'm not talking about explaining how it works, rather what kind of output it generates, and what kind of performance it has (where it shines and where it doesn't). Does it support generating 'move' and 'copy' typed changes? Does it attempt to minimize the number of changes in the patch at all?

Some explanation here would make it much easier to evaluate whether this module is appropriate in a given situation.

Broken link in the readme

The link objectdiff on npm is broken http://search.npmjs.org/#/objectdiff . Actually the link would work with npmjs.com at https://www.npmjs.com/search?q=objectdiff OR https://www.npmjs.com/package/objectdiff.

Implement objectDiff.patch(target, diff)