复杂数组去重

数组去重 内部可能会有数组,对象

用例

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
var arr1 = [1, 1, '1', '1']
var arr2 = [
{},
{},
{
a: 1,
b: 1
},
{
a: 1,
b: 1
},
[1, 2],
[1, 2]
];
var arr3 = [
{
a: 1,
b: {
a: 1,
b: {
a: 1,
b: 1
},
},
},
{
a: 1,
b: {
a: 1,
b: {
a: 1,
b: 1
},
},
},
];

结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
arr1 = [1, '1'];
arr2 = [
{},
{
a: 1,
b: 1
},
[1, 2],
];
arr3 = [
{
a: 1,
b: {
a: 1,
b: {
a: 1,
b: 1
},
},
},
]

代码

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

console.log(unique(arr1));
console.log(unique(arr2));
console.log(unique(arr3));

function unique(arr) {
var result = [];
var len = arr.length;
for (var i = 0; i < len; i++) {
var isExist = false;
for (var j = i + 1; j < len; j++) {
if (isEqual(arr[i],arr[j])) {
isExist = true;
}
}
if (isExist) {
isExist = false;
continue;
}
result.push(arr[i]);
}
return result;
}

// isEqual typeof null, object, arr
/**
* isEqual
* [] object
* [] arr
*/
function isEqual(a, b) {
var toString = Object.prototype.toString;
var typeA = toString.call(a);
var typeB = toString.call(b);
if (typeof a === 'object' && typeof b === 'object') {
if (typeA === '[object Number]' && a !== b) return true; // NaN
if (typeA === '[object Array]') {
var aLen = a.length;
var bLen = b.length;
if (a === b) return true;
if (aLen !== bLen) return false;
if (a == null || b == null) return false;
var newa = a.slice();
var newb = b.slice();
newa.sort();
newb.sort();
while(aLen--) {
if(!isEqual(newa[aLen], newb[aLen])) return false;
}
return true;
}
if (typeA === '[object Object]') {
for (var propA in a) {
if (a.hasOwnProperty(propA)) {
if (!b.hasOwnProperty(propA)) {
return false;
} else {
return isEqual(a[propA], b[propA]);
}
}
}
// 判断是否为空对象
for (var propB in b) {
return false;
}
return true;
}
} else if (a === b) {
return true;
} else {
return false;
}
}

function isEmptyObj(a) {
var toString = Object.prototype.toString;
if (toString.call(a) !== '[object Object]') throw new Error(a +' is not a object');
for(var prop in a) {
return false;
}
return true;
}

// console.log(isEqual(1, 1)) // t
// console.log(isEqual(1, 2)) // f
// console.log(isEqual([], [])) // t
// console.log(isEqual([1, 1], [1, 1])) // t
// console.log(isEqual([1, 1], [1, 2])) // f
// console.log(isEqual({
// a: 1,
// b: 1
// }, {
// a: 1,
// b: 1
// })) // t
// console.log(isEqual({
// a: 1,
// b: 1
// }, {
// a: 1,
// b: 2
// })) // f