10 examples of 'deep equal' in JavaScript

8
function shallowEqual(actual, expected) {
9
  const keys = Object.keys(expected);
10
11
  for (const key of keys) {
12
    if (actual[key] !== expected[key]) {
13
      return false;
14
    }
15
  }
16
17
  return true;
18
}

220
function shallowEqual(actual, expected) {
221
  var keys = Object.keys(expected);
222
223
  var _arr2 = keys;
224
  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
225
    var key = _arr2[_i2];
226
    if (actual[key] !== expected[key]) {
227
      return false;
228
    }
229
  }
230
231
  return true;
232
}

3
export default function shallowEqual(objA: Object, objB: Object): boolean {
4
  if (objA === objB) {
5
    return true;
6
  }
7
8
  if (
9
    typeof objA !== 'object' ||
10
    objA === null ||
11
    typeof objB !== 'object' ||
12
    objB === null
13
  ) {
14
    return false;
15
  }
16
17
  const keysA = Object.keys(objA);
18
  const keysB = Object.keys(objB);
19
20
  if (keysA.length !== keysB.length) {
21
    return false;
22
  }
23
24
  // Test for A's keys different from B.
25
  const bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
26
  for (let i = 0; i < keysA.length; i++) {
27
    if (!bHasOwnProperty(keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
28
      return false;
29
    }
30
  }
31
32
  return true;
33
}

73
export function shallowEqual(objA, objB) {
74
  if (is(objA, objB)) return true
75
  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
76
    return false
77
  }
78
  const keysA = Object.keys(objA)
79
  const keysB = Object.keys(objB)
80
  if (keysA.length !== keysB.length) return false
81
  for (let i = 0; i < keysA.length; i++) {
82
    if (!objB.hasOwnProperty(keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
83
      return false
84
    }
85
  }
86
  return true
87
}

71
export function deepEquals(x: any, y: any): boolean {
72
  if (x === y || x === null || y === null) {
73
    return x === y
74
  } else if (Array.isArray(x) || Array.isArray(y)) {
75
    return (
76
      Array.isArray(x) &&
77
      Array.isArray(y) &&
78
      x.length == y.length &&
79
      x.every((e, i) => deepEquals(e, y[i]))
80
    )
81
  } else if (typeof x === 'object' && typeof y === 'object') {
82
    const xk = Object.keys(x).sort()
83
    const yk = Object.keys(y).sort()
84
    return deepEquals(xk, yk) && xk.every(k => deepEquals(x[k], y[k]))
85
  } else {
86
    return false
87
  }
88
}

14
export function shallowEqual(objA, objB) {
15
  if (objA === objB) return true
16
17
  const keysA = Object.keys(objA)
18
  const keysB = Object.keys(objB)
19
20
  // Test for A's keys different from B's.
21
  for (var i = 0; i < keysA.length; i++) {
22
    if (objA[keysA[i]] !== objB[keysA[i]]) return false
23
  }
24
25
  // Test for B's keys different from A's.
26
  // Handles the case where B has a property that A doesn't.
27
  for (var i = 0; i < keysB.length; i++) {
28
    if (objA[keysB[i]] !== objB[keysB[i]]) return false
29
  }
30
31
  return true
32
}

7
function shallowEqual(a, b) { // eslint-disable-line flowtype/require-parameter-type
8
    if (a === b) {
9
        return true;
10
    }
11
12
    let countA = 0;
13
    let countB = 0;
14
15
    for (const key in a) { // eslint-disable-line no-restricted-syntax
16
        if (hasOwn.call(a, key) && a[key] !== b[key]) {
17
            return false;
18
        }
19
20
        countA += 1;
21
    }
22
23
    for (const key in b) { // eslint-disable-line no-restricted-syntax
24
        if (hasOwn.call(b, key)) {
25
            countB += 1;
26
        }
27
    }
28
29
    return countA === countB;
30
}

544
function _deepEqual(actual, expected) {
545
	if (actual === expected)
546
		return true;
547
	else if (actual instanceof Date && expected instanceof Date)
548
		return actual.getTime() === expected.getTime();
549
	else if (actual instanceof RegExp && expected instanceof RegExp)
550
		return actual.source === expected.source && actual.global === expected.global && actual.multiline === expected.multiline && actual.lastIndex === expected.lastIndex && actual.ignoreCase === expected.ignoreCase;
551
	else if (typeof actual != 'object' && typeof expected != 'object')
552
		return actual == expected;
553
	else
554
		return objEquiv(actual, expected);
555
}

130
function shallowEqual(a: string[], b: string[]): boolean {
131
  if (!Array.isArray(a) || !Array.isArray(b)) return false;
132
  if (a === b) return true;
133
  if (a.length !== b.length) return false;
134
  for (const item of a) {
135
    if (b.indexOf(item) === -1) return false;
136
  }
137
  return true;
138
}

183
function deepEquals(x, y) {
184
    if (x === null || x === undefined || y === null || y === undefined) { return x === y; }
185
    if (x === y || x.valueOf() === y.valueOf()) { return true; }
186
    if (Array.isArray(x) && x.length !== y.length) { return false; }
187
188
    if (!(x instanceof Object)) { return false; }
189
    if (!(y instanceof Object)) { return false; }
190
191
    var p = Object.keys(x);
192
    return Object.keys(y).every(function (i) { return p.indexOf(i) !== -1; }) &&
193
        p.every(function (i) { return deepEquals(x[i], y[i]); });
194
}