我想比较两个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;
}}
}
答案 0 :(得分：4)
快速而有限
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;
}
答案 1 :(得分：4)
在Javascript / Typescript中（如果两个对象的键顺序相同）：使用
JSON.stringify(obj1) === JSON.stringify(obj2) 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
使用Lodash，与键的顺序无关
_.isEqual(obj1 , obj2 ); // true
分别比较对象的每个键
答案 2 :(得分：0)
您可以使用for-of和find方法获得结果：
for(let item of this.formAll) {
if (this.formAb.find((i) => { i.id === item.id})){
item.selected = true;
}
}
答案 3 :(得分：0)
使用过滤器效果更好。
this.formAll = JSON.parse(response)
this.formAll.forEach((element) => {
this.formAb.filter((element1) => {
if (element1.id === element.id ) {
element.selected = true;
}
})
})
答案 4 :(得分：0)
对于Angular，请使用Deep Equal
import * as deepEqual from "deep-equal";
console.log(deepEqual({a:123},{a:123})); // True
答案 5 :(得分：0)
比较两个Json对象，例如： 目标1：
{
id : 1,
name : 'HADY',
status : false
}
obj 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;
}
它只会返回引用： obj
{
name : 'HADY',
status : false
}
答案 6 :(得分：0)
轻松简单！
如果对象键相同且顺序一致，JSON.stringify(Obj2)的工作速度最快：
Obj1 = { fruit: '?' };
Obj2 = { fruit: '?' };
JSON.stringify(Obj1) === JSON.stringify(Obj2);
答案 7 :(得分：0)
我认为比较“ JSON.Stringify”方法不正确； Next Variant还可以检查递归对象：
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]);
});
}
}
}