比较JavaScript中的对象数组

Comparing Arrays of Objects in JavaScript

我想比较JavaScript代码中2个对象数组。这些对象共有8个属性，但是每个对象都不会有一个值，并且数组永远不会大于8个项目，因此可能需要遍历每个对象然后查看对象的值的蛮力方法。 8个属性是执行我想做的最简单的方法，但是在实现之前，我想看看是否有人有一个更优雅的解决方案。有什么想法吗？

编辑：您不能在JavaScript解释器的当前基于浏览器的常见实现中重载运算符。

要回答最初的问题，可以用一种方法来做到这一点，请注意，这有点麻烦，只需将两个数组序列化为JSON，然后比较两个JSON字符串即可。这只会告诉您数组是否不同，显然您可以对数组中的每个对象执行此操作，以查看哪些对象不同。

另一个选择是使用一个具有一些比较对象的工具的库-我使用并推荐MochiKit。

编辑：kamens给出的答案也值得考虑，因为一个用于比较两个给定对象的函数将比任何库都要小得多，以执行我建议的操作(尽管我的建议当然可以很好地工作)。

这是一个幼稚的实现，可能仅对您有用-请注意此实现存在潜在的问题：

1
2
3
4
5
6
7
8
9
10

function objectsAreSame(x, y) {
var objectsAreSame = true;
for(var propertyName in x) {
if(x[propertyName] !== y[propertyName]) {
objectsAreSame = false;
break;
}
}
return objectsAreSame;
}

假定两个对象都具有相同的确切属性列表。

哦，很明显，无论好坏，我都属于唯一的一个返回点阵营。 :)

我知道这是一个古老的问题，提供的答案很好用...但这有点短，不需要任何其他库(即JSON)：

1
2
3

function arraysAreEqual(ary1,ary2){
return (ary1.join('') == ary2.join(''));
}

老实说，最多有8个对象，每个对象最多有8个属性，最好的选择是只遍历每个对象并直接进行比较。它会很快并且会很容易。

如果您将经常使用这些类型的比较，那么我就Jason关于JSON序列化的观点表示同意...但是否则，无需使用新的库或JSON序列化代码来减慢您的应用程序的速度。

我已经做了一些简单的算法来比较两个对象的内容并返回可理解的差异列表。以为我会分享。它借鉴了jQuery的一些想法，即map函数实现以及对象和数组类型检查。

它返回"差异对象"列表，该列表是具有差异信息的数组。非常简单

这里是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

// compare contents of two objects and return a list of differences
// returns an array where each element is also an array in the form:
// [accessor, diffType, leftValue, rightValue ]
//
// diffType is one of the following:
// value: when primitive values at that index are different
// undefined: when values in that index exist in one object but don't in
// another; one of the values is always undefined
// null: when a value in that index is null or undefined; values are
// expressed as boolean values, indicated wheter they were nulls
// type: when values in that index are of different types; values are
// expressed as types
// length: when arrays in that index are of different length; values are
// the lengths of the arrays
//

function DiffObjects(o1, o2) {
// choose a map() impl.
// you may use $.map from jQuery if you wish
var map = Array.prototype.map?
function(a) { return Array.prototype.map.apply(a, Array.prototype.slice.call(arguments, 1)); } :
function(a, f) {
var ret = new Array(a.length), value;
for ( var i = 0, length = a.length; i < length; i++ )
ret[i] = f(a[i], i);
return ret.concat();
};

// shorthand for push impl.
var push = Array.prototype.push;

// check for null/undefined values
if ((o1 == null) || (o2 == null)) {
if (o1 != o2)
return [["","null", o1!=null, o2!=null]];

return undefined; // both null
}
// compare types
if ((o1.constructor != o2.constructor) ||
(typeof o1 != typeof o2)) {
return [["","type", Object.prototype.toString.call(o1), Object.prototype.toString.call(o2) ]]; // different type

}

// compare arrays
if (Object.prototype.toString.call(o1) =="[object Array]") {
if (o1.length != o2.length) {
return [["","length", o1.length, o2.length]]; // different length
}
var diff =[];
for (var i=0; i<o1.length; i++) {
// per element nested diff
var innerDiff = DiffObjects(o1[i], o2[i]);
if (innerDiff) { // o1[i] != o2[i]
// merge diff array into parent's while including parent object name ([i])
push.apply(diff, map(innerDiff, function(o, j) { o[0]="[" + i +"]" + o[0]; return o; }));
}
}
// if any differences were found, return them
if (diff.length)
return diff;
// return nothing if arrays equal
return undefined;
}

// compare object trees
if (Object.prototype.toString.call(o1) =="[object Object]") {
var diff =[];
// check all props in o1
for (var prop in o1) {
// the double check in o1 is because in V8 objects remember keys set to undefined
if ((typeof o2[prop] =="undefined") && (typeof o1[prop] !="undefined")) {
// prop exists in o1 but not in o2
diff.push(["[" + prop +"]","undefined", o1[prop], undefined]); // prop exists in o1 but not in o2

}
else {
// per element nested diff
var innerDiff = DiffObjects(o1[prop], o2[prop]);
if (innerDiff) { // o1[prop] != o2[prop]
// merge diff array into parent's while including parent object name ([prop])
push.apply(diff, map(innerDiff, function(o, j) { o[0]="[" + prop +"]" + o[0]; return o; }));
}

}
}
for (var prop in o2) {
// the double check in o2 is because in V8 objects remember keys set to undefined
if ((typeof o1[prop] =="undefined") && (typeof o2[prop] !="undefined")) {
// prop exists in o2 but not in o1
diff.push(["[" + prop +"]","undefined", undefined, o2[prop]]); // prop exists in o2 but not in o1

}
}
// if any differences were found, return them
if (diff.length)
return diff;
// return nothing if objects equal
return undefined;
}
// if same type and not null or objects or arrays
// perform primitive value comparison
if (o1 != o2)
return [["","value", o1, o2]];

// return nothing if values are equal
return undefined;
}

由于序列化通常不起作用(仅当属性的顺序匹配：JSON.stringify({a:1,b:2}) !== JSON.stringify({b:2,a:1})时)，您必须检查属性的计数并比较每个属性：

1
2
3
4
5
6
7
8
9
10

如果需要深入比较，可以递归调用该函数：

1
2
3
4
5
6
7
8
9
10
11
12

然后，使用此函数比较数组中的对象很容易：

1
2
3
4
5
6
7
8
9

const arr1 = [obj1, obj1];
const arr2 = [obj1, obj2];
const arr3 = [obj1, obj3];

const arraysEqual = (a1, a2) =>
a1.length === a2.length && a1.every((o, idx) => objectsEqual(o, a2[idx]));

console.log(arraysEqual(arr1, arr2)); // true
console.log(arraysEqual(arr1, arr3)); // false

我尝试了JSON.stringify()并为我工作。

1
2
3
4
5
6
7

let array1 = [1,2,{value:'alpha'}] , array2 = [{value:'alpha'},'music',3,4];

JSON.stringify(array1) //"[1,2,{"value":"alpha"}]"

JSON.stringify(array2) //"[{"value":"alpha"},"music",3,4]"

JSON.stringify(array1) === JSON.stringify(array2); // false

使用来自lodash的_.some：https://lodash.com/docs/4.17.11#some

1
2
3
4

const array1AndArray2NotEqual =
_.some(array1, (a1, idx) => a1.key1 !== array2[idx].key1
|| a1.key2 !== array2[idx].key2
|| a1.key3 !== array2[idx].key3);

这是我的尝试，使用Node的assert模块+ npm包object-hash。

我想您想检查两个数组是否包含相同的对象，即使这些对象在两个数组之间的排列顺序不同。