Every line of 'deep equal' code snippets is scanned for vulnerabilities by our powerful machine learning engine that combs millions of open source libraries, ensuring your JavaScript code is secure.
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 }