快速且有限

JSON.stringify(obj1) === JSON.stringify(obj2)

缓慢且更通用

Object.equals = function( x, y ) {
    if ( x === y ) return true;
    // if both x and y are null or undefined and exactly the same

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

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

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

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

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

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

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

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

在Javascript/Typescript中（如果两个对象的键顺序相同）：使用

1. JSON.stringify(obj1) === JSON.stringify(obj2)
2. Object.entries(obj1).toString() === Object.entries(obj2).toString()
obj1 = { a:1, b:2 }obj2 = { a:1, b:2 }// true
obj1 = { a:1, b:2 }obj2 = { b:2, a:1 }// false
   1.使用Lodash，不考虑键的顺序
   _.isEqual(obj1 , obj2 ); // true
   1.分别比较对象的每个键

对于Angular ，请使用深度相等

import * as deepEqual from "deep-equal";

console.log(deepEqual({a:123},{a:123})); // True

您可以使用for-of和find方法来实现结果，如下所示：

for(let item  of this.formAll) {
    if (this.formAb.find((i) => { i.id === item.id})){
       item.selected = true;
    }
}

使用过滤器效果更好。

this.formAll = JSON.parse(response)
    this.formAll.forEach((element) => {
      this.formAb.filter((element1) => {
        if (element1.id === element.id ) {
          element.selected = true;
        }
     })
     })

比较两个Json对象以收集示例：目标1：

{
id : 1,
name : 'HADY',
status : false
}

目标2：

{
id : 1,
name : 'example',
surename : 'example',
nickname : 'example'
status : true
}

-------------------------------------------------------compare（obj1，obj2）{

const keys1 = [];
    const values1 = [];
    Object.keys(obj1).forEach((element) => {
      keys1.push(element);
    });
    Object.values(obj1).forEach((element) => {
      values1.push(element);
    });
    const keys2 = [];
    const values2 = [];
    Object.keys(obj2).forEach((element) => {
      keys2.push(element);
    });
    Object.values(obj2).forEach((element) => {
      values2.push(element);
    });
    const obj = {};
    keys1.forEach((element, i) => {
      for (let index = 0; index < keys2.length; index++) {
        if (element === keys2[index]) {
          if (values1[i] !== values2[index]) {
            const jsonKey = element;
            obj[jsonKey] = values1[i];
          }
          break;
        }
      }
    });
    console.log(obj);
    return obj;
  }

它将只返回尊重：目标

{
name : 'HADY',
status : false
}

轻松简单！

• 如果对象键相同且按顺序排列，则JSON.stringify(Obj2)工作最快：*

Obj1 = { fruit: '🥝' };
Obj2 = { fruit: '🥝' };

JSON.stringify(Obj1) === JSON.stringify(Obj2);

我认为比较“JSON.Stringify”方法不正确;下一个检查递归对象的变体：

interface IComparator<T> {
  equals(obj: T, other: T): boolean;
}

export default class Comparator<T> implements IComparator<T> {
  equals(item: T, otherItem: T): boolean {
    if (typeof item !== typeof otherItem) {
      return false;
    }

    const objectCache: any[] = [];
    const otherObjectCache: any[] = [];
    const getIndexFromCache = (compareObject: any, cacheArray: any[]): number =>
      cacheArray.findIndex((item) => item === compareObject);

    switch (true) {
      case item === otherItem:
        return true;
      case typeof item !== 'object':
        return item === otherItem;
      case item === null || otherItem === null:
        return item === null && otherItem === null;
      case Object.keys(item).length !== Object.keys(otherItem).length:
        return false;
      default:
        const object = item as any;
        const otherObject = otherItem as any;

        return Object.keys(object).every((key: string) => {
          const hasKeyInOtherObject = Object.prototype.hasOwnProperty.call(otherItem, key);

          if (!hasKeyInOtherObject) {
            return false;
          }

          const cacheObjectIndex = getIndexFromCache(object[key], objectCache);
          const cacheOtherObjectIndex = getIndexFromCache(otherObject[key], otherObjectCache);

          if (cacheObjectIndex !== cacheOtherObjectIndex) {
            return false;
          }

          const isEqualsCacheObjects =
            cacheObjectIndex !== -1 && cacheOtherObjectIndex !== -1 && cacheObjectIndex === cacheOtherObjectIndex;

          if (isEqualsCacheObjects) {
            return true;
          }

          objectCache.push(object[key]);
          otherObjectCache.push(otherObject[key]);

          return new Comparator<any>().equals(object[key], otherObject[key]);
        });
    }
  }
}

用玩笑来测试它：

import Comparator from './Comparator';

export default describe('Comparator', () => {
  const recursiveA: { value: number; b?: any } = { value: 1 };
  const recursiveB: { value: number; a?: any } = { value: 2 };

  recursiveA.b = recursiveB;
  recursiveB.a = recursiveA;

  it.each([
    [null, null, true],
    [undefined, undefined, true],
    [1, 1, true],
    ['test', 'test', true],
    [[1, 2], [1, 2], true],
    [{ a: 1, b: 3 }, { a: 1, b: 3 }, true],
    [2, 1, false],
    ['test', 'test2', false],
    [[1, 2], [2, 1], false],
    [{ a: 1, b: 3 }, { a: 3, b: 1 }, false],
    [recursiveA, recursiveB, false],
    [null, 1, false],
    [null, {}, false],
    [undefined, null, false],
    [1, '1', false],
  ])('compares values %o and %o are equal: %s', (value1: any, value2: any, expectedResult: boolean) => {
    const comparator = new Comparator<any>();
    const actualResult = comparator.equals(value1, value2);

    expect<boolean>(actualResult).toBe(expectedResult);
  });
});

JavaScript版本：

export default class Comparator {
    equals(item, otherItem) {
        if (typeof item !== typeof otherItem) {
            return false;
        }

        const objectCache = [];
        const otherObjectCache = [];
        const getIndexFromCache = (compareObject, cacheArray) => cacheArray.findIndex((item) => item === compareObject);

        switch (true) {
            case item === otherItem:
                return true;
            case typeof item !== 'object':
                return item === otherItem;
            case item === null || otherItem === null:
                return item === null && otherItem === null;
            case Object.keys(item).length !== Object.keys(otherItem).length:
                return false;
            default:
                const object = item;
                const otherObject = otherItem;

                return Object.keys(object).every((key) => {
                    const hasKeyInOtherObject = Object.prototype.hasOwnProperty.call(otherItem, key);

                    if (!hasKeyInOtherObject) {
                        return false;
                    }

                    const cacheObjectIndex = getIndexFromCache(object[key], objectCache);
                    const cacheOtherObjectIndex = getIndexFromCache(otherObject[key], otherObjectCache);

                    if (cacheObjectIndex !== cacheOtherObjectIndex) {
                        return false;
                    }

                    const isEqualsCacheObjects = cacheObjectIndex !== -1 && cacheOtherObjectIndex !== -1 && cacheObjectIndex === cacheOtherObjectIndex;

                    if (isEqualsCacheObjects) {
                        return true;
                    }

                    objectCache.push(object[key]);
                    otherObjectCache.push(otherObject[key]);

                    return new Comparator().equals(object[key], otherObject[key]);
                });
        }
    }
}

我的建议是逐个比较对象的字段：

private compareTwoObjects(object1: any, object2: any): boolean {
    let compareRes = true;
    if (Object.keys(object1).length === Object.keys(object2).length) {
      Object.keys(object1).forEach(key => {
        if (object1[key] !== object2[key]) {
          compareRes = false;
        }
      });
    } else {
      compareRes = false;
    }
    return compareRes;
  }