Íme egy tömör megoldás a Lodash használatával:

_.differenceWith(a, b, _.isEqual);

Vegye figyelembe, hogy mindkét bemenetnek tömbnek kell lennie (esetleg egy objektum tömbjének).

Ha rekurzív módon meg szeretné mutatni, hogy egy objektum miben különbözik a többitől, használhatja a _.reduce függvényt az _.isEqual és az _.isPlainObject elemekkel kombinálva. Ebben az esetben összehasonlíthatja, hogy a miben különbözik b-től, vagy miben különbözik b a-tól:

const objectA = {
  a: {
    1: "SAME WILL BE MISSING IN RESULT", 
    2: "BBB", 
    3: [1, 2, 3]
  }, 
  b: "not", 
  c: "foo bar"
};
const objectB = {
  a: {
    1: "SAME WILL BE MISSING IN RESULT",
    2: [1, 2]
  }, 
  b: "foo", 
  c: "bar"
};

const diff = function(obj1, obj2) {
  return _.reduce(obj1, function(result, value, key) {
if (_.isPlainObject(value)) {
  result[key] = diff(value, obj2[key]);
} else if (!_.isEqual(value, obj2[key])) {
  result[key] = value;
}
return result;
  }, {});
};

const diffAOverB = diff(objectA, objectB);
const diffBOverA = diff(objectA, objectB);
console.log(diffAOverB);
console.log(diffBOverA);

<script src="https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js"></script>

Ez a kód egy objektumot ad vissza minden olyan tulajdonsággal, amelynek eltérő értéke van, és mindkét objektum értékét is. Hasznos a különbség naplózásához.

var allkeys = _.union(_.keys(obj1), _.keys(obj2));
var difference = _.reduce(allkeys, function (result, key) {
  if ( !_.isEqual(obj1[key], obj2[key]) ) {
    result[key] = {obj1: obj1[key], obj2: obj2[key]}
  }
  return result;
}, {});

Egyszerűen használható _.isEqual módszer, minden összehasonlításnál működni fog...

• Megjegyzés: Ez a módszer támogatja a tömbök, tömbpufferek, logikai értékek, * dátumobjektumok, hibaobjektumok, térképek, számok, Object objektumok, regexek, * halmazok, karakterláncok, szimbólumok és beírt tömbök összehasonlítását. Object objektumok összehasonlítása * saját, nem öröklött, felsorolható tulajdonságaik alapján történik. A funkciók és a DOM * csomópontok nem támogatottak.

Tehát ha van lent:

 const firstName = {name: "Alireza"};
 const otherName = {name: "Alireza"};

Ha így tesz: _.isEqual(firstName, otherName);,

az igaz értéket adja vissza

És ha const fullName = {firstName: "Alireza", familyName: "Dezfoolian"};

Ha így tesz: _.isEqual(firstName, fullName);,

false értéket ad vissza

Megszúrtam egy Adam Boduch kódot, hogy mély különbséget adjak ki – ez teljesen nem tesztelt, de a darabok ott vannak:

function diff (obj1, obj2, path) {
    obj1 = obj1 || {};
    obj2 = obj2 || {};

    return _.reduce(obj1, function(result, value, key) {
        var p = path ? path + '.' + key : key;
        if (_.isObject(value)) {
            var d = diff(value, obj2[key], p);
            return d.length ? result.concat(d) : result;
        }
        return _.isEqual(value, obj2[key]) ? result : result.concat(p);
    }, []);
}

diff({ foo: 'lol', bar: { baz: true }}, {}) // returns ["foo", "bar.baz"]

Mély összehasonlítás a (beágyazott) tulajdonságok sablonjával az ellenőrzéshez

function objetcsDeepEqualByTemplate(objectA, objectB, comparisonTemplate) {
  if (!objectA || !objectB) return false

  let areDifferent = false
  Object.keys(comparisonTemplate).some((key) => {
    if (typeof comparisonTemplate[key] === 'object') {
      areDifferent = !objetcsDeepEqualByTemplate(objectA[key], objectB[key], comparisonTemplate[key])
      return areDifferent
    } else if (comparisonTemplate[key] === true) {
      areDifferent = objectA[key] !== objectB[key]
      return areDifferent
    } else {
      return false
    }
  })

  return !areDifferent
}

const objA = { 
  a: 1,
  b: {
    a: 21,
    b: 22,
  },
  c: 3,
}

const objB = { 
  a: 1,
  b: {
    a: 21,
    b: 25,
  },
  c: true,
}

// template tells which props to compare
const comparisonTemplateA = {
  a: true,
  b: {
    a: true
  }
}
objetcsDeepEqualByTemplate(objA, objB, comparisonTemplateA)
// returns true

const comparisonTemplateB = {
  a: true,
  c: true
}
// returns false
objetcsDeepEqualByTemplate(objA, objB, comparisonTemplateB)

Ez a konzolban működni fog. A tömb támogatása szükség esetén hozzáadható

Ahogy kérdeztük, itt van egy rekurzív objektum-összehasonlító függvény. És még egy kicsit. Feltételezve, hogy az ilyen funkció elsődleges használata az objektumvizsgálat, van mondanivalóm. A teljes mélységű összehasonlítás rossz ötlet, ha egyes különbségek nem relevánsak. Például a vak mély összehasonlítás a TDD állításokban szükségtelenné teszi a teszteket. Emiatt egy sokkal értékesebb részleges különbséget szeretnék bemutatni. Ez a szál egy korábbi hozzájárulásának rekurzív analógja. Figyelmen kívül hagyja az a-ban nem található kulcsokat

var bdiff = (a, b) =>
    _.reduce(a, (res, val, key) =>
        res.concat((_.isPlainObject(val) || _.isArray(val)) && b
            ? bdiff(val, b[key]).map(x => key + '.' + x) 
            : (!b || val != b[key] ? [key] : [])),
        []);

A BDiff lehetővé teszi a várt értékek ellenőrzését, miközben más tulajdonságokat is tolerál, és pontosan ezt szeretné az automatikus ellenőrzéshez. Ez lehetővé teszi mindenféle fejlett állítás létrehozását. Például:

var diff = bdiff(expected, actual);
// all expected properties match
console.assert(diff.length == 0, "Objects differ", diff, expected, actual);
// controlled inequality
console.assert(diff.length < 3, "Too many differences", diff, expected, actual);

Visszatérve a teljes megoldáshoz. Teljes hagyományos diff felépítése bdiff-fel triviális:

function diff(a, b) {
    var u = bdiff(a, b), v = bdiff(b, a);
    return u.filter(x=>!v.includes(x)).map(x=>' < ' + x)
    .concat(u.filter(x=>v.includes(x)).map(x=>' | ' + x))
    .concat(v.filter(x=>!u.includes(x)).map(x=>' > ' + x));
};

A fenti függvény futtatása két összetett objektumon valami ehhez hasonló kimenetet eredményez:

 [
  " < components.0.components.1.components.1.isNew",
  " < components.0.cryptoKey",
  " | components.0.components.2.components.2.components.2.FFT.min",
  " | components.0.components.2.components.2.components.2.FFT.max",
  " > components.0.components.1.components.1.merkleTree",
  " > components.0.components.2.components.2.components.2.merkleTree",
  " > components.0.components.3.FFTResult"
 ]

Végül, annak érdekében, hogy bepillantást nyerhessünk az értékek különbségébe, érdemes közvetlenül eval() a diff kimenetet. Ehhez szükségünk van a bdiff csúnyább verziójára, amely szintaktikailag helyes útvonalakat ad ki:

// provides syntactically correct output
var bdiff = (a, b) =>
    _.reduce(a, (res, val, key) =>
        res.concat((_.isPlainObject(val) || _.isArray(val)) && b
            ? bdiff(val, b[key]).map(x => 
                key + (key.trim ? '':']') + (x.search(/^\d/)? '.':'[') + x)
            : (!b || val != b[key] ? [key + (key.trim ? '':']')] : [])),
        []);

// now we can eval output of the diff fuction that we left unchanged
diff(a, b).filter(x=>x[1] == '|').map(x=>[x].concat([a, b].map(y=>((z) =>eval('z.' + x.substr(3))).call(this, y)))));

Ez valami ehhez hasonlót fog kiadni:

[" | components[0].components[2].components[2].components[2].FFT.min", 0, 3]
[" | components[0].components[2].components[2].components[2].FFT.max", 100, 50]

MIT licenc ;)

Tudnom kell, hogy van-e különbség valamelyik beágyazott tulajdonságukban

Más válaszok potenciálisan kielégítő megoldásokat kínálnak erre a problémára, de ez elég nehéz és gyakori, hogy úgy tűnik, van egy nagyon népszerű csomag a probléma megoldására. mély-objektum-diff.

A csomag használatához npm i deep-object-diff, majd:

const { diff } = require('deep-object-diff');
var a = {};
var b = {};

a.prop1 = 2;
a.prop2 = { prop3: 2 };

b.prop1 = 2;
b.prop2 = { prop3: 3 };

if (!_.isEqual(a, b)) {
  const abDiff = diff(a, b);
  console.log(abDiff);
  /*
  {
    prop2: {
      prop3: 3
    }
  }
  */
}

// or alternatively
const abDiff = diff(a, b);
if(!_.isEmpty(abDiff)) {
  // if a diff exists then they aren't deeply equal
  // perform needed actions with diff...
}

Íme egy részletesebb eset a tulajdonok közvetlenül a dokumentumokból való törlésével kapcsolatban:

const lhs = {
  foo: {
    bar: {
      a: ['a', 'b'],
      b: 2,
      c: ['x', 'y'],
      e: 100 // deleted
    }
  },
  buzz: 'world'
};

const rhs = {
  foo: {
    bar: {
      a: ['a'], // index 1 ('b')  deleted
      b: 2, // unchanged
      c: ['x', 'y', 'z'], // 'z' added
      d: 'Hello, world!' // added
    }
  },
  buzz: 'fizz' // updated
};

console.log(diff(lhs, rhs)); // =>
/*
{
  foo: {
    bar: {
      a: {
        '1': undefined
      },
      c: {
        '2': 'z'
      },
      d: 'Hello, world!',
      e: undefined
    }
  },
  buzz: 'fizz'
}
*/

A megvalósítás részleteiért és egyéb használati információkért tekintse meg az adott repót.

A lodash/aláhúzás használata nélkül írtam ezt a kódot, és jól működik számomra az objektum1 és az objektum2 mély összehasonlításában.

function getObjectDiff(a, b) {
    var diffObj = {};
    if (Array.isArray(a)) {
        a.forEach(function(elem, index) {
            if (!Array.isArray(diffObj)) {
                diffObj = [];
            }
            diffObj[index] = getObjectDiff(elem, (b || [])[index]);
        });
    } else if (a != null && typeof a == 'object') {
        Object.keys(a).forEach(function(key) {
            if (Array.isArray(a[key])) {
                var arr = getObjectDiff(a[key], b[key]);
                if (!Array.isArray(arr)) {
                    arr = [];
                }
                arr.forEach(function(elem, index) {
                    if (!Array.isArray(diffObj[key])) {
                        diffObj[key] = [];
                    }
                    diffObj[key][index] = elem;
                });
            } else if (typeof a[key] == 'object') {
                diffObj[key] = getObjectDiff(a[key], b[key]);
            } else if (a[key] != (b || {})[key]) {
                diffObj[key] = a[key];
            } else if (a[key] == (b || {})[key]) {
                delete a[key];
            }
        });
    }
    Object.keys(diffObj).forEach(function(key) {
        if (typeof diffObj[key] == 'object' && JSON.stringify(diffObj[key]) == '{}') {
            delete diffObj[key];
        }
    });
    return diffObj;
}

Tudom, hogy ez nem válaszol közvetlenül az OP kérdésére, de a lodash eltávolításának módja vezetett ide. Szóval remélhetőleg ez segít valakinek, aki hasonló helyzetben van, mint én.

A jóváírás a következő címre érkezett: @JohanPersson. Ebből a válaszból építettem ki a mélyen beágyazott értékek összehasonlítását és a különbségekre vonatkozó kulcshivatkozást

getObjectDiff = (obj1, obj2) => {
    const obj1Props = Object.keys(obj1);
    const obj2Props = Object.keys(obj2);

    const keysWithDiffValue = obj1Props.reduce((keysWithDiffValueAccumulator, key) => {
      const propExistsOnObj2 = obj2.hasOwnProperty(key);
      const hasNestedValue = obj1[key] instanceof Object && obj2[key] instanceof Object;
      const keyValuePairBetweenBothObjectsIsEqual = obj1[key] === obj2[key];

      if (!propExistsOnObj2) {
        keysWithDiffValueAccumulator.push(key);
      } else if (hasNestedValue) {
        const keyIndex = keysWithDiffValueAccumulator.indexOf(key);
        if (keyIndex >= 0) {
          keysWithDiffValueAccumulator.splice(keyIndex, 1);
        }
        const nestedDiffs = getObjectDiff(obj1[key], obj2[key]);
        for (let diff of nestedDiffs) {
          keysWithDiffValueAccumulator.push(`${key}.${diff}`);
        }
      } else if (keyValuePairBetweenBothObjectsIsEqual) {
        const equalValueKeyIndex = keysWithDiffValueAccumulator.indexOf(key);
        keysWithDiffValueAccumulator.splice(equalValueKeyIndex, 1);
      }
      return keysWithDiffValueAccumulator;
    }, obj2Props);

    return keysWithDiffValue;
  }
const obj1 = {a0: {a1: {a2: {a3: 'Im here'}}}};
const obj2 = {a0: {a1: {a2: {a3: 'Not here', b3: 'some'}}}};
console.log('final', getObjectDiff(obj1, obj2));

Adam Boduch válaszát kiegészítve ez a tulajdonságok különbségeit veszi figyelembe

const differenceOfKeys = (...objects) =>
  _.difference(...objects.map(obj => Object.keys(obj)));
const differenceObj = (a, b) => 
  _.reduce(a, (result, value, key) => (
    _.isEqual(value, b[key]) ? result : [...result, key]
  ), differenceOfKeys(b, a));

Ha csak a kulcsok összehasonlítására van szüksége:

 _.reduce(a, function(result, value, key) {
     return b[key] === undefined ? key : []
  }, []);

Itt van egy egyszerű Typescript Lodash mély különbség-ellenőrzővel, amely egy új objektumot hoz létre, amely csak a régi és egy új objektum közötti különbségeket tartalmazza.

Például, ha rendelkezünk:

const oldData = {a: 1, b: 2};
const newData = {a: 1, b: 3};

a kapott objektum a következő lenne:

const result: {b: 3};

Kompatibilis a többszintű mély objektumokkal is, tömböknél szükség lehet némi módosításra.

import * as _ from "lodash";

export const objectDeepDiff = (data: object | any, oldData: object | any) => {
  const record: any = {};
  Object.keys(data).forEach((key: string) => {
    // Checks that isn't an object and isn't equal
    if (!(typeof data[key] === "object" && _.isEqual(data[key], oldData[key]))) {
      record[key] = data[key];
    }
    // If is an object, and the object isn't equal
    if ((typeof data[key] === "object" && !_.isEqual(data[key], oldData[key]))) {
      record[key] = objectDeepDiff(data[key], oldData[key]);
    }
  });
  return record;
};

Ez a követelmény volt a két json-frissítés közötti különbség eléréséhez az adatbázis-frissítések nyomon követéséhez. Talán valaki más is hasznosnak találja ezt.

https://gist.github.com/jp6rt/7fcb6907e159d78e

const {
  isObject,
  isEqual,
  transform,
  has,
  merge,
} = require('lodash');
const assert = require('assert');

/**
 * Perform a symmetric comparison on JSON object.
 * @param {*} baseObj - The base object to be used for comparison against the withObj.
 * @param {*} withObj - The withObject parameter is used as the comparison on the base object.
 * @param {*} invert  - Because this is a symmetric comparison. Some values in the with object
 *                      that doesn't exist on the base will be lost in translation.
 *                      You can execute again the function again with the parameters interchanged.
 *                      However you will lose the reference if the value is from the base or with
 *                      object if you intended to do an assymetric comparison.
 *                      Setting this to true will do make sure the reference is not lost.
 * @returns           - The returned object will label the result of the comparison with the
 *                      value from base and with object.
 */
const diffSym = (baseObj, withObj, invert = false) => transform(baseObj, (result, value, key) => {
  if (isEqual(value, withObj[key])
    && has(withObj, key)) {
    return;
  }

  if (isObject(value)
    && isObject(withObj[key])
    && !Array.isArray(value)) {
    result[key] = diffSym(value, withObj[key], invert);
    return;
  }

  if (!invert) {
    result[key] = {
      base: value,
      with: withObj[key],
    };
    return;
  }

  if (invert) {
    result[key] = {
      base: withObj[key],
      with: value,
    };
  }
});

/**
 * Perform a assymmetric comparison on JSON object.
 * @param {*} baseObj - The base object to be used for comparison against the withObj.
 * @param {*} withObj - The withObject parameter is used as the comparison on the base object.
 * @returns           - The returned object will label the values with
 *                      reference to the base and with object.
 */
const diffJSON = (baseObj, withObj) => {
  // Deep clone the objects so we don't update the reference objects.
  const baseObjClone = JSON.parse(JSON.stringify(baseObj));
  const withObjClone = JSON.parse(JSON.stringify(withObj));

  const beforeDelta = diffSym(baseObjClone, withObjClone);
  const afterDelta = diffSym(withObjClone, baseObjClone, true);

  return merge(afterDelta, beforeDelta);
};

// By Example:

const beforeDataObj = {
  a: 1,
  c: { d: 2, f: 3 },
  g: 4,
  h: 5,
};
const afterDataObj = {
  a: 2,
  b: 3,
  c: { d: 1, e: 1 },
  h: 5,
};

const delta = diffJSON(beforeDataObj, afterDataObj);

// Assert expected result.
assert(isEqual(delta, {
  a: { base: 1, with: 2 },
  b: { base: undefined, with: 3 },
  c: {
    d: { base: 2, with: 1 },
    e: { base: undefined, with: 1 },
    f: { base: 3, with: undefined },
  },
  g: { base: 4, with: undefined },
}));

Sok válasz érkezett, de azok számára, akik kíváncsiak, hogy ne írjanak kódot két, bármilyen típusú szerkezetű objektum közötti különbség kiszámításához, van egy könyvtár, amely ezt megteheti. A Lodash isEqual csak igazat vagy hamisat ad vissza, nem ad vissza semmilyen információt a megváltozott tulajdonságokról. https://www.npmjs.com/package/deep-diff

a két objektum közötti különbségek teljes részletét adja vissza

import DeepDiff from 'deep-diff';
let a = {...} //some object
let b = {...} //some object 
var differences = DeepDiff.diff(a, b);

Hasonló kérdést tettek fel ebben a szálban is A 2 JSON-objektum közötti különbség megállapítása a>

ennek alapja a @JLavoie, a lodash használatával

let differences = function (newObj, oldObj) {
      return _.reduce(newObj, function (result, value, key) {
        if (!_.isEqual(value, oldObj[key])) {
          if (_.isArray(value)) {
            result[key] = []
            _.forEach(value, function (innerObjFrom1, index) {
              if (_.isNil(oldObj[key][index])) {
                result[key].push(innerObjFrom1)
              } else {
                let changes = differences(innerObjFrom1, oldObj[key][index])
                if (!_.isEmpty(changes)) {
                  result[key].push(changes)
                }
              }
            })
          } else if (_.isObject(value)) {
            result[key] = differences(value, oldObj[key])
          } else {
            result[key] = value
          }
        }
        return result
      }, {})
    }

https://jsfiddle.net/EmilianoBarboza/0g0sn3b9/8/

A Sridhar Gudimela válaszára való építkezés érdekében itt TypeScriptet használó módon frissítjük:

///  U T I L S

interface LooseObjectInterface {
  [key: string]: any;
};

type inputOptions = LooseObjectInterface | any[];



///  E X P O R T

export const objectCompare = (objectA: inputOptions, objectB: inputOptions): LooseObjectInterface => {
  let diffObj: LooseObjectInterface = {};

  switch(true) {
    case (Array.isArray(objectA)):
      objectA.forEach((elem: any, index: number) => {
        if (!Array.isArray(diffObj))
          diffObj = [];

        diffObj[index] = objectCompare(elem, (objectB || [])[index]);
      });

      break;

    case (objectA !== null && typeof objectA === "object"):
      Object.keys(objectA).forEach((key: any) => {
        if (Array.isArray(objectA[key])) {
          let arr = objectCompare(objectA[key], objectB[key]);

          if (!Array.isArray(arr))
            arr = [];

          arr.forEach((elem: any, index: number) => {
            if (!Array.isArray(diffObj[key]))
              diffObj[key] = [];

            diffObj[key][index] = elem;
          });
        } else if (typeof objectA[key] === "object")
          diffObj[key] = objectCompare(objectA[key], objectB[key]);
        else if (objectA[key] !== (objectB || {})[key])
          diffObj[key] = objectA[key];
        else if (objectA[key] === (objectB || {})[key])
          delete objectA[key];
      });

      break;

    default:
      break;
  }

  Object.keys(diffObj).forEach((key: any) => {
    if (typeof diffObj[key] === "object" && JSON.stringify(diffObj[key]) === "{}")
      delete diffObj[key];
  });

  return diffObj;
};

EDIT: Az eredeti válaszom a Flow-t használta, ezért a negatív szavazatok (feltételezem, vagy talán azért, mert a válaszom nem a Lodash-t használta... de ha egy hasonló problémára válaszolok, az nem árt).

csak vanilla js-t használunk

let a = {};
let b = {};

a.prop1 = 2;
a.prop2 = { prop3: 2 };

b.prop1 = 2;
b.prop2 = { prop3: 3 };

JSON.stringify(a) === JSON.stringify(b);
// false
b.prop2 = { prop3: 2};

JSON.stringify(a) === JSON.stringify(b);
// true