-
Star
(620)
You must be signed in to star a gist -
Fork
(93)
You must be signed in to fork a gist
-
-
Save Yimiprod/7ee176597fef230d1451 to your computer and use it in GitHub Desktop.
| /** | |
| * This code is licensed under the terms of the MIT license | |
| * | |
| * Deep diff between two object, using lodash | |
| * @param {Object} object Object compared | |
| * @param {Object} base Object to compare with | |
| * @return {Object} Return a new object who represent the diff | |
| */ | |
| function difference(object, base) { | |
| function changes(object, base) { | |
| return _.transform(object, function(result, value, key) { | |
| if (!_.isEqual(value, base[key])) { | |
| result[key] = (_.isObject(value) && _.isObject(base[key])) ? changes(value, base[key]) : value; | |
| } | |
| }); | |
| } | |
| return changes(object, base); | |
| } |
worked !! thanks 👍
That's fantastic! Thanks!
Thanks a lot to everyone to let that gist be alive with a lot of propositions, don't know if i have the time to update it to a newer / better version, there's a lot of good proposals !
Awesome. Thanks. Perfect solution to what I am looking for.
Awesome man ! cheers from Colorado
Having 2 arrays that are equal at the start(a,b) and then manipulating only array b, doesn't always show that there's a diff.
For example if from the starting, while they are equal, I add an item to b, it shows a difference,
but if I remove an item from b, it doesn't show that there was a difference.
One way to solve it is -
const diff = [...difference(a,b), ...difference(b,a)]
That way I get the difference, whether items were added or removed from b.
Thanks!!!
Mi contribution:
function difference(object, base) {
return _.transform(object, (result, value, key) => {
if (!_.isEqual(value, base[key])) {
result[key] = (_.isObject(value) && _.isObject(base[key])) ? difference(value, base[key]) : value;
}
});
}
@srijan-devops I hope this function helps you:
function clean (obj) {
// Check nil values
if (_.isNil(obj)) return null;
// Check array values
if (_.isArray(obj)) {
const newValue = _.filter(_.map(obj, clean), _.identify);
return _.isEmpty(newValue) ? null : newValue;
}
// Check object values
if (_.isObject(obj)) {
const newValue = _.transform(obj, (result, value, key) => {
const newValue = clean(value);
if (!_.isNil(newValue)) {
result[key] = newValue;
}
}, {});
return _.isEmpty(newValue) ? null : newValue;
}
// Other values
return obj;
}
This is my vanilla way, i hope it help somebody.
/**
* Recursive diff between two object
* @param {Object} base Object to compare with
* @param {Object} object Object compared
* @return {Object} Return a new object who represent the diff OR Return FALSE if there is no difference
*/
function differenceBetweenObjects (base,object){
let diff = false;
if(typeof object == 'object'){
for(let k in object){
if(typeof object[k] != 'object'){
if(base[k] != object[k]){
if(diff == false){diff = {};}
diff[k] = object[k];
}
}
else{
let subDiff = differenceBetweenObjects(base[k],object[k]);
if(subDiff !== false){
if(diff == false){diff = {};}
diff[k] = subDiff;
}
}
}
}
if(typeof base == 'object'){
for(let k in base){
if(!object.hasOwnProperty(k)){
diff[k] = null;
}
}
}
return diff;
}
This is my vanilla way, i hope it help somebody.
/** * Recursive diff between two object * @param {Object} base Object to compare with * @param {Object} object Object compared * @return {Object} Return a new object who represent the diff OR Return FALSE if there is no difference */ function differenceBetweenObjects (base,object){ let diff = false; if(typeof object == 'object'){ for(let k in object){ if(typeof object[k] != 'object'){ if(base[k] != object[k]){ if(diff == false){diff = {};} diff[k] = object[k]; } } else{ let subDiff = differenceBetweenObjects(base[k],object[k]); if(subDiff !== false){ if(diff == false){diff = {};} diff[k] = subDiff; } } } } return diff; }
Doesn't work with this:
differenceBetweenObjects({a: 2, b: [1,2,3,4], c: {r: 34534}}, {a: 1, b: [1,2,3,4,5]})
This is my vanilla way, i hope it help somebody.
/** * Recursive diff between two object * @param {Object} base Object to compare with * @param {Object} object Object compared * @return {Object} Return a new object who represent the diff OR Return FALSE if there is no difference */ function differenceBetweenObjects (base,object){ let diff = false; if(typeof object == 'object'){ for(let k in object){ if(typeof object[k] != 'object'){ if(base[k] != object[k]){ if(diff == false){diff = {};} diff[k] = object[k]; } } else{ let subDiff = differenceBetweenObjects(base[k],object[k]); if(subDiff !== false){ if(diff == false){diff = {};} diff[k] = subDiff; } } } } return diff; }Doesn't work with this:
differenceBetweenObjects({a: 2, b: [1,2,3,4], c: {r: 34534}}, {a: 1, b: [1,2,3,4,5]})
I forgot detecting missing keys from base object. Try now. Thanks the report.
/**
* Deep diff between two object, using lodash
* @param {Object} base Object to compare with
* @param {Object} object Object compared
* @return {Object} Return a new object who represent the diff OR Return FALSE if there is no difference
*/
function differenceBetweenObjects (base,object){
let diff = false;
if(typeof object == 'object'){
for(let k in object){
if(typeof object[k] != 'object'){
if(base[k] != object[k]){
if(diff == false){diff = {};}
diff[k] = object[k];
}
}
else{
let subDiff = differenceBetweenObjects(base[k],object[k]);
if(subDiff !== false){
if(diff == false){diff = {};}
diff[k] = subDiff;
}
}
}
}
if(typeof base == 'object'){
for(let k in base){
if(!object.hasOwnProperty(k)){
diff[k] = null;
}
}
}
return diff;
}
I am thinking. Should I check missing keys recusive if base object's item is an object? Like this:
function differenceBetweenObjects (base,object){
let diff = false;
if(typeof object == 'object' && typeof base == 'object'){
for(let k in object){
if(typeof object[k] != 'object'){
if(base[k] != object[k]){
if(diff == false){diff = {};}
diff[k] = object[k];
}
}
else{
let subDiff = differenceBetweenObjects(base[k],object[k]);
if(subDiff !== false){
if(diff == false){diff = {};}
diff[k] = subDiff;
}
}
}
}
if(typeof base == 'object'){
for(let k in base){
if(typeof object != 'object' || !object.hasOwnProperty(k)){
if(diff == false){diff = {};}
if(typeof base[k] == 'object'){
let subDiff = differenceBetweenObjects(base[k]);
diff[k] = subDiff;
}
else{
diff[k] = null;
}
}
}
}
return diff;
}
If you also want to know what the differences are:
https://stackoverflow.com/questions/8572826/generic-deep-diff-between-two-objects
I'm the 500th person to save this snippet:-)
Thank you, very nice and clean!
I agree with you @jvanderberg and I used it for typescipt!
thanks , it helps a lot
Awesome code! I did a small change to deal with an array of objects as a key of the object we wanted to diff:
export const deepDiffBetweenObjects = (object, base) => {
const changes = (object, base) => {
return transform(object, (result, value, key) => {
if (!isEqual(value, base[key])) {
if (isArray(value)) {
result[key] = difference(value, base[key])
} else if (isObject(value) && isObject(base[key])) {
result[key] = changes(value, base[key])
} else {
result[key] = value
}
}
})
}
return changes(object, base)
}
@chtseac Yours was the best solution I've found so far, thank you from Dublin!
Sharing my own update - I needed to only compare some top-level properties of two objects, so added an optional third parameter to take an array of paths to specifically check.
let changes = deepDiff(previousValue, newValue, [
"customisations",
"customisations.localeOverrides", // won't work currently - someone smarter can me can try make it work :)
"onboarding"
]);
function deepDiff(fromObject, toObject, specificPaths) {
const changes = {};
console.log('specificPaths:', specificPaths);
const buildPath = (path, obj, key) =>
_.isUndefined(path) ? key : `${path}.${key}`;
let obj1 = {}; obj2 = {}
if(specificPaths && specificPaths.length > 0){
// only look at specific paths if specified
for (const path of specificPaths) {
if(fromObject[path]) obj1[path] = fromObject[path];
if(toObject[path]) obj2[path] = toObject[path]
}
} else {
obj1 = fromObject
obj2 = toObject
}
const walk = (fromObject, toObject, path) => {
for (const key of _.keys(fromObject)) {
const currentPath = buildPath(path, fromObject, key);
if (!_.has(toObject, key)) {
changes[currentPath] = { from: _.get(fromObject, key) };
}
}
for (const [key, to] of _.entries(toObject)) {
const currentPath = buildPath(path, toObject, key);
if (!_.has(fromObject, key)) {
changes[currentPath] = { to };
} else {
const from = _.get(fromObject, key);
if (!_.isEqual(from, to)) {
if (_.isObjectLike(to) && _.isObjectLike(from)) {
walk(from, to, currentPath);
} else {
changes[currentPath] = { from, to };
}
}
}
}
};
walk(obj1, obj2);
return changes;
}
Here is an update of @Chippd with specifics paths
`
function deepDiff(fromObject, toObject, specificPaths) {
const changes = {};
console.log('specificPaths:', specificPaths);
const buildPath = (path, __, key) =>
_.isUndefined(path) ? key : `${path}.${key}`;
let obj1 = {};
let obj2 = {}
if (_.isArray(specificPaths) && !_.isEmpty(specificPaths)) {
for (const path of specificPaths) {
if (_.has(fromObject, path)) {
_.set(obj1, path, _.get(fromObject, path));
} else if (_.has(toObject, path)) {
changes[path] = {to: _.get(toObject, path)};
}
if (_.has(toObject, path)) {
_.set(obj2, path, _.get(toObject, path));
} else if (_.has(fromObject, path)) {
changes[path] = {from: _.get(fromObject, path)};
}
}
} else {
obj1 = fromObject
obj2 = toObject
}
const walk = (fromObject, toObject, path) => {
for (const key of _.keys(fromObject)) {
const currentPath = buildPath(path, fromObject, key);
if (!_.has(toObject, key)) {
changes[currentPath] = { from: _.get(fromObject, key) };
}
}
for (const [key, to] of _.entries(toObject)) {
const currentPath = buildPath(path, toObject, key);
if (!_.has(fromObject, key)) {
changes[currentPath] = { to };
} else {
const from = _.get(fromObject, key);
if (!_.isEqual(from, to)) {
if (_.isObjectLike(to) && _.isObjectLike(from)) {
walk(from, to, currentPath);
} else {
changes[currentPath] = { from, to };
}
}
}
}
};
walk(obj1, obj2);
return changes;
}
const previousValue = {
customisations: {
localeOverrides: {
foo: 1,
},
bar: 2
},
bar: [1,2,3],
onboarding: {
foo: 1
},
foo: 1
}
const newValue = {
customisations: {
localeOverrides: {
daz: 1,
},
bar: 2,
daz: 2
},
onboarding: {
foo: 4
},
baz: 2
}
const changes = deepDiff(previousValue, newValue, [
"customisations",
"customisations.localeOverrides",
"onboarding"
]);
// Only specific path
const changes2 = deepDiff(previousValue, newValue, [
"customisations.localeOverrides",
"bar"
]);
// test only if validate that array is present and isn't empty
const changes3 = deepDiff(previousValue, newValue, []);
// no array present
const changes4 = deepDiff(previousValue, newValue);
console.log('compare result various paths', changes);
console.log('compare result Only specific path', changes2);
console.log('compare result test only if validate that array is present and isn't empty', changes3);
console.log('compare result no array present', changes4);
`
Just one example works fine in my case (shallow diff):
const diffData = _.fromPairs( _.differenceWith(_.toPairs(sourceData), _.toPairs(valuesToDiffWith), _.isEqual), )
any suggestions for deep diff?
thank you, it helps me and makes me look prop :). lodash is superbe
Just another shallow diff
const shallowDiff = Object.entries(object1).reduce(
(diff, [key, value]) =>
_isEqual(object2[key], value) ? diff : { ...diff, [key]: value },
{},
)
@Andrei-Fogoros didn't thinked about licence at the time i posted it, but since you're asking, it's a good occasion to put it under MIT License.
@Andrei-Fogoros didn't thinked about licence at the time i posted it, but since you're asking, it's a good occasion to put it under MIT License.
Great, thank you very much! :)
Not sure if anyone needs this variation, but here's one I made to basically create a separate JSON object with ONLY the changes with accurate child items.
import * as _ from 'lodash';
/**
* Deep diff between two object-likes
* @param {Object} fromObject the original object
* @param {Object} toObject the updated object
* @return {Object} a new object which represents the diff
*/
export function deepDiff(fromObject, toObject) {
const changes = {};
const buildPath = (path, obj, key) => {
const origVal = _.get(obj, key);
if (_.isUndefined(path)) {
if (_.isArray(origVal)) {
changes[key] = [];
} else if (_.isObject(origVal)) {
changes[key] = {};
}
} else {
if (_.isArray(origVal)) {
path[key] = [];
} else if (_.isObject(origVal)) {
path[key] = {};
}
}
return [_.isUndefined(path) ? changes : path, key]
}
const walk = (fromObject, toObject, path) => {
for (const key of _.keys(fromObject)) {
const objKeyPair = buildPath(path, fromObject, key);
if (!_.has(toObject, key)) {
objKeyPair[0][objKeyPair[1]] = { from: _.get(fromObject, key) };
}
}
for (const [key, to] of _.entries(toObject)) {
const isLast = _.has(fromObject, key);
const objKeyPair = buildPath(path, fromObject, key);
if (isLast) {
const from = _.get(fromObject, key);
if (!_.isEqual(from, to)) {
if (_.isObjectLike(to) && _.isObjectLike(from)) {
walk(from, to, objKeyPair[0][objKeyPair[1]]);
} else {
objKeyPair[0][objKeyPair[1]] = { __old: from, __new: to };
}
} else {
delete objKeyPair[0][objKeyPair[1]]
}
} else {
objKeyPair[0][objKeyPair[1]] = { to };
}
}
};
walk(fromObject, toObject);
return changes;
}
ty
Recently I've been having some success with this one-liner:
const deepDiff = (a, b) => ({});Not sure if it is just my machine, but I've found it to be significantly faster than any of the alternative recommendations in the thread.
Maybe not the fastest, and does not cover many features added above but quite concise and readable alternative: