Benchmark: lodash omit vs. spread omit

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Tests:

lodash merge
const a = { aa: 'oh', bb: 'my' }; const b = _.omit(a, 'aa');
spread
const a = { aa: 'oh', bb: 'my' }; const { aa, ...b } = a;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash merge
spread

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36 Edg/137.0.0.0

Browser/OS: Chrome 137 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash merge	3910547.5 Ops/sec
spread	35565736.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

I'd be happy to help explain the benchmark.

The provided JSON represents a JavaScript microbenchmark test on MeasureThat.net. The benchmark is comparing two approaches: using Lodash's `omit` function and using the spread operator (`...`) in combination with destructuring (`{ aa, ...b } = a;`).

**Lodash's `omit` Function**

Lodash is a popular utility library for JavaScript that provides various helper functions to simplify common tasks. The `omit` function returns a new object with the specified properties removed.

In this benchmark, Lodash's `omit` function is used to remove specific properties from an object (`a`). For example:
```javascript
const a = { aa: 'oh', bb: 'my' };
const b = _.omit(a, 'aa');
```
This would result in `b` being `{ bb: 'my' }`, with the `aa` property removed.

**Spread Operator and Destructuring**

The spread operator (`...`) is a feature introduced in ECMAScript 2015 (ES6). It allows you to create a new object by copying all own enumerable properties from one or more source objects. In combination with destructuring, it enables the creation of new objects without modifying the original.

In this benchmark, the spread operator and destructuring are used to extract specific properties from an object (`a`). For example:
```javascript
const a = { aa: 'oh', bb: 'my' };
const { aa, ...b } = a;
```
This would result in `aa` being `'oh'`, and `b` being `{ bb: 'my' }`. The spread operator creates a new object (`b`) that contains all properties from `a`, except for the specified property (`aa`).

**Pros and Cons**

Here are some pros and cons of each approach:

**Lodash's `omit` Function**

Pros:

* Easy to use and understand
* Provides a specific solution for removing properties from an object

Cons:

* Requires importing Lodash library, which may add extra size to the bundle
* May not be as efficient as native JavaScript implementation (e.g., using `Object.keys()` and `reduce()`)

**Spread Operator and Destructuring**

Pros:

* Native JavaScript implementation, so no additional library is required
* Efficient and fast

Cons:

* Requires understanding of spread operator and destructuring syntax
* May require more code to achieve the same result as Lodash's `omit` function

**Other Considerations**

When using Lodash's `omit` function, it's worth noting that it creates a new object with the specified properties removed. This may not be desirable in some cases, where you want to modify the original object instead.

Using the spread operator and destructuring can also lead to more code being written, especially if you're dealing with complex objects or multiple properties to extract.

**Alternative Implementations**

If you prefer a native JavaScript implementation over Lodash's `omit` function, you can use the following approach:
```javascript
function omit(obj, keys) {
  return Object.keys(obj).reduce((acc, key) => {
    if (!keys.includes(key)) {
      acc[key] = obj[key];
    }
    return acc;
  }, {});
}
```
This implementation uses `Object.keys()` and `reduce()` to create a new object with the specified properties removed.

In summary, Lodash's `omit` function provides an easy-to-use solution for removing properties from an object, but it requires importing an additional library. The spread operator and destructuring approach is more efficient and native JavaScript implementation, but may require more code and understanding of advanced syntax.

Related benchmarks:

lodash omit vs. spread omit (version: 0)

Comparing performance of: lodash merge vs spread

Created: 6 years ago by: Guest

Jump to the latest result

lodash merge

spread

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):