Benchmark: Lodash omit vs es6 rest spread vs for-in-loop

HTML Preparation code:

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

Script Preparation code:

var allHeaders = {
  'Accept-Encoding': 'gzip,deflate',
  'Accept-Language': 'en-US',
  'Content-Type': 'application/json',
  'User-Agent': `(compatible; Mozilla/5.0; MSIE 9.0; Trident/5.0;})`,
  'Proxy-Connection': 'Keep-Alive',
  Connection: 'Keep-Alive',
  Accept: 'application/hal+json, application/json',
};

function omit(obj, keys) {
  var result = {};
  for (let i in obj) {
    if (keys.indexOf(i) >= 0) continue;
    result[i] = obj[i];
  }
  return result;
}

Tests:

lodash omit for 3 keys
_.omit(allHeaders, ['Accept-Encoding', 'User-Agent', 'Connection']);
native for in loop for 3 keys
omit(allHeaders, ['Accept-Encoding', 'User-Agent', 'Connection']);
lodash omit for 2 keys
_.omit(allHeaders, ['Accept-Encoding', 'Connection']);
native for in loop for 2 keys
omit(allHeaders, ['Accept-Encoding', 'Connection']);
lodash omit for 1 keys
_.omit(allHeaders, ['Connection']);
native for in loop for 1 keys
omit(allHeaders, ['Connection']);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash omit for 3 keys
native for in loop for 3 keys
lodash omit for 2 keys
native for in loop for 2 keys
lodash omit for 1 keys
native for in loop for 1 keys

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36 Edg/105.0.1343.42

Browser/OS: Chrome 105 on Windows

View result in a separate tab

Test name	Executions per second
lodash omit for 3 keys	582483.4 Ops/sec
native for in loop for 3 keys	3575706.0 Ops/sec
lodash omit for 2 keys	519432.3 Ops/sec
native for in loop for 2 keys	3290181.5 Ops/sec
lodash omit for 1 keys	522757.9 Ops/sec
native for in loop for 1 keys	2997678.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript functions is crucial in ensuring optimal code execution.

**Benchmark Overview**

The provided benchmark compares three approaches to remove specific keys from an object:

1. **Lodash `omit` function**
2. **Native `for-in-loop` approach**
3. **ES6 rest spread operator (`...`) with `Object.fromEntries`**

Each test case uses the same input data, but varies the number of keys to be omitted.

**Lodash `omit` function**

The Lodash `omit` function is a utility function that removes specified properties from an object. It takes two arguments: the object to modify (`obj`) and an array of property names to exclude (`keys`). The function returns a new object with only the included properties.

Pros:

* Concise and readable code
* Well-documented and widely used

Cons:

* Adds overhead due to the creation of a new object
* Requires Lodash library, which may not be included in all environments

**Native `for-in-loop` approach**

This approach uses a traditional `for-in-loop` to iterate over the object's properties and only includes those that are not present in the `keys` array. This method is more explicit and easier to understand.

Pros:

* No additional library required
* Can be optimized for performance

Cons:

* More verbose code
* May require additional bookkeeping to handle property names correctly

**ES6 rest spread operator (`...`) with `Object.fromEntries`**

This approach uses the rest spread operator (`...`) to create a new array of key-value pairs, excluding those that are present in the `keys` array. The resulting array is then passed to `Object.fromEntries`, which creates a new object from it.

Pros:

* Concise and expressive code
* Modern syntax

Cons:

* May not be supported in older browsers or environments
* Requires understanding of modern JavaScript features

**Comparison of Approaches**

Based on the benchmark results, the ES6 rest spread operator (`...`) with `Object.fromEntries` appears to be the fastest approach, followed closely by the native `for-in-loop` approach. The Lodash `omit` function is slower due to the overhead of creating a new object.

**Other Considerations**

* **Library usage**: If the Lodash library is not available or can't be included in the environment, the native `for-in-loop` approach may be a better choice.
* **Performance optimization**: For performance-critical code, using native loops and avoiding additional libraries like Lodash can lead to faster execution times.
* **Code readability and maintainability**: The use of a library like Lodash can improve code readability and maintainability, especially for complex logic.

**Alternatives**

For similar benchmarking scenarios:

* Use `Object.fromEntries` alone without the rest spread operator for a more explicit approach
* Use a custom implementation of `omit` using a native loop instead of Lodash
* Test with different object sizes or complexity to see how the approaches scale

Keep in mind that these alternatives may not offer significant performance improvements, but they can provide alternative perspectives on the problem.

Related benchmarks:

Lodash omit vs es6 rest spread vs for-in-loop (version: 0)

Comparing performance of: lodash omit for 3 keys vs native for in loop for 3 keys vs lodash omit for 2 keys vs native for in loop for 2 keys vs lodash omit for 1 keys vs native for in loop for 1 keys

Created: 4 years ago by: Guest

Jump to the latest result

lodash omit for 3 keys

native for in loop for 3 keys

lodash omit for 2 keys

native for in loop for 2 keys

lodash omit for 1 keys

native for in loop for 1 keys

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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