<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.20/lodash.min.js"></script>function equal(a, b) { if (a === b) return true; if (a && b && typeof a == 'object' && typeof b == 'object') { if (a.constructor !== b.constructor) return false; var length, i, keys; if (Array.isArray(a)) { length = a.length; if (length != b.length) return false; for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false; return true; } if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); keys = Object.keys(a); length = keys.length; if (length !== Object.keys(b).length) return false; for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; for (i = length; i-- !== 0;) { var key = keys[i]; if (!equal(a[key], b[key])) return false; } return true; } // true if both NaN, false otherwise return a!==a && b!==b;};// 1 level deepvar data = [ { description: 'equal numbers', value1: 1, value2: 1, equal: true, }, { description: 'not equal numbers', value1: 1, value2: 2, equal: false, }, { description: 'number and array are not equal', value1: 1, value2: [], equal: false, }, { description: '0 and null are not equal', value1: 0, value2: null, equal: false, }, { description: 'equal strings', value1: 'a', value2: 'a', equal: true, }, { description: 'big object', value1: { prop1: 'value1', prop2: 'value2', prop3: 'value3', prop4: { subProp1: 'sub value1', subProp2: { subSubProp1: 'sub sub value1', subSubProp2: [ 1, 2, { prop2: 1, prop: 2 }, 4, 5, ], }, }, prop5: 1000, prop6: new Date(2016, 2, 10), }, value2: { prop5: 1000, prop3: 'value3', prop1: 'value1', prop2: 'value2', prop6: new Date('2016/03/10'), prop4: { subProp2: { subSubProp1: 'sub sub value1', subSubProp2: [ 1, 2, { prop2: 1, prop: 2 }, 4, 5, ], }, subProp1: 'sub value1', }, }, equal: true, }, ];data.forEach((item) => { _.isEqual(item.value1, item.value2); });data.forEach((item) => { equal(item.value1, item.value2); });--enable-precise-memory-info flag.
| Test case name | Result |
|---|---|
| lodash | |
| fast-deep-equal |
| Test name | Executions per second |
|---|---|
| lodash | 169145.4 Ops/sec |
| fast-deep-equal | 109669.8 Ops/sec |
I'll break down the provided benchmark and explain what's being tested, compared, and their pros and cons.
Benchmark Overview
The benchmark is designed to measure the performance of two JavaScript functions: _.isEqual from the Lodash library and a custom function named equal. Both functions are used to compare the equality of two values in an array.
Custom Function (Fast-Deep-Equal)
The custom function equal is responsible for checking if two values are equal. It's designed to handle nested objects, arrays, and primitive types. Here's a high-level overview of its logic:
=== operator.Lodash Function (_.isEqual)
The Lodash function _.(isEqual) is designed to check if two values are equal. It's a more comprehensive implementation than the custom equal function.
Comparison
Both functions aim to achieve the same goal: checking if two values are equal. However, they differ in their approach:
equal function uses a more straightforward, iterative approach, which might be faster for small arrays but could become slower for larger datasets._.(isEqual) function is more comprehensive and optimized for performance, making it suitable for handling large datasets.Pros and Cons
Custom Function (Fast-Deep-Equal)
Pros:
Cons:
Lodash Function (_.isEqual)
Pros:
Cons:
Other Considerations
forEach method, which might not be the best approach for measuring performance. Other methods like for loops or map functions could provide more accurate results.Overall, both implementations have their strengths and weaknesses. While the custom equal function is simple and lightweight, it's less comprehensive than the Lodash implementation. In contrast, the Lodash _.(isEqual) function offers better performance and handling of complex data structures, making it a more suitable choice for large-scale applications.
