如何通过两个对象比较打字稿角度6

Question

我想比较两个 Json 对象数组。一个有更多的数据。对于最终结果，如果一个 id 找到另一个 id，则选中的复选框 = true。到目前为止有 4 个，它只找到一个。我是否先遍历长数组，然后再遍历第二个数组以查找匹配项？

this.formAll = JSON.parse(response)
for (var i = 0; i < this.formAll.length; i++) {
for (var j = i; j <  this.formAb.length; j++) {
console.log( this.formAb[j].id,  this.formAll[i].SeriesNumber);
if ( this.formAll[i].id === this.formAb[j].id) {
console.log( 'small=', this.formAb[j].id, 'large=', 
this.formAll[i].id );
this.formAll[i].selected = true;
}}
}

Answer 1

快速且有限

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;
}

Answer 2

在 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

3. 使用 Lodash ，无论键的顺序如何

   _.isEqual(obj1 , obj2 ); // true

4. 单独比较对象的每个键

Answer 3

对于角度使用 Deep Equal

import * as deepEqual from "deep-equal";
console.log(deepEqual({a:123},{a:123})); // True

Answer 4

您可以使用for-of和find方法获得结果，例如：

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

Answer 5

使用过滤器效果更好。

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

Answer 6

比较两个 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
}

Answer 7

我认为比较"JSON。字符串化"方法不正确; 下一个变体，还检查递归对象：

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]);
});
}
}
}

Answer 8

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

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;
}

Answer 9

变得简单易行！！

如果对象键相同且顺序相同，则JSON.stringify(Obj2)工作速度最快：

Obj1 = { fruit: '🥝' };
Obj2 = { fruit: '🥝' };
JSON.stringify(Obj1) === JSON.stringify(Obj2);