Benchmark: omit vanilla vs. lodash

HTML Preparation code:

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

Script Preparation code:

function createObj(size) {
  return Array(size)
    .fill(0)
    .map(() => String.fromCodePoint(Math.trunc(Math.random() * 26 + 97)))
    .reduce((acc, char, i) => ({ ...acc, [`${char}${i}`]: i }), {})
}

var obj = createObj(1000)
var keys = Object.keys(obj).filter(() => Math.random() < 0.5)

Tests:

vanilla set
const result = {} const keySet = new Set(keys) for (const key of Object.keys(obj)) { if (!keySet.has(key)) { result[key] = obj[key] } }
vanilla object in
const result = {} const keyObj = {} for (const key of keys) { keyObj[key] = true } for (const key of Object.keys(obj)) { if (!(key in keyObj)) { result[key] = obj[key] } }
vanilla object coerce
const result = {} const keyObj = {} for (const key of keys) { keyObj[key] = true } for (const key of Object.keys(obj)) { if (keyObj[key]) { result[key] = obj[key] } }
vanilla array
const result = {} for (const key of Object.keys(obj)) { if (!keys.includes(key)) { result[key] = obj[key] } }
vanilla delete spread
const result = { ...obj } for (const key of keys) { delete result[key] }
vanilla delete assign
const result = Object.assign({}, obj) for (const key of keys) { delete result[key] }
lodash omit
_.omit(obj, keys)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
vanilla set
vanilla object in
vanilla object coerce
vanilla array
vanilla delete spread
vanilla delete assign
lodash omit

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its various components.

**Benchmark Definition**

The benchmark is to compare the performance of different approaches for filtering an object or array in JavaScript, specifically:

* `_.omit(obj, keys)` (using Lodash)
* Vanila Set
* Vanila Object In
* Vanila Object Coerce
* Vanila Delete Spread
* Vanila Delete Assign

**Options Compared**

Each option is compared using the same input data structure: an object with 1000 properties, where each property has a random key and value.

**Pros and Cons of Each Approach**

1. **Lodash `_.omit(obj, keys)`**: This approach uses the Lodash library to filter out specific keys from the object.
	* Pros: Easy to use, efficient, and well-tested.
	* Cons: Requires an additional library download, and may not be suitable for small projects.
2. **Vanilla Set**: This approach creates a set of keys to exclude and then iterates over the object using `Object.keys()` and `Set`.
	* Pros: Lightweight, easy to understand, and does not require any external libraries.
	* Cons: May be slower due to the overhead of creating a set, especially for large datasets.
3. **Vanilla Object In**: This approach creates an object with all keys as boolean values (true) and then iterates over the original object using `Object.keys()`.
	* Pros: Similar to Vanilla Set but avoids the creation of a separate boolean object.
	* Cons: May have similar performance characteristics to Vanilla Set due to the set creation overhead.
4. **Vanilla Object Coerce**: This approach creates an object with all keys as boolean values (true) and then iterates over the original object using `Object.keys()`, but uses a coercion operator (`!!`) to convert each key value to a boolean.
	* Pros: Similar to Vanilla Set, but avoids creating a separate boolean object.
	* Cons: May have similar performance characteristics to Vanilla Set due to the set creation overhead and additional coercion operations.
5. **Vanilla Delete Spread**: This approach creates a new object using the spread operator (`{...obj}`) and then iterates over the original object using `Object.keys()` and deletes each key-value pair.
	* Pros: Simple, easy to understand, and does not require any external libraries.
	* Cons: May be slower due to the overhead of creating a new object and iterating over it multiple times.
6. **Vanilla Delete Assign**: This approach uses the `delete` operator on the original object and then iterates over the keys using `Object.keys()` to delete each key-value pair.
	* Pros: Lightweight, easy to understand, and does not require any external libraries.
	* Cons: May be slower due to the overhead of deleting each property individually.

**Conclusion**

The choice of approach depends on the specific use case and performance requirements. If you need a lightweight and easy-to-understand solution, Vanilla Set or Vanilla Object In might be suitable options. However, if you prioritize efficiency and readability, Lodash `_.omit(obj, keys)` is likely to be the best choice. The other approaches may have similar performance characteristics due to the set creation overhead and additional operations.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:129.0) Gecko/20100101 Firefox/129.0

Browser/OS: Firefox 129 on Linux

View result in a separate tab

Test name	Executions per second
vanilla set	8446.8 Ops/sec
vanilla object in	6727.9 Ops/sec
vanilla object coerce	7744.6 Ops/sec
vanilla array	522.1 Ops/sec
vanilla delete spread	7869.0 Ops/sec
vanilla delete assign	8432.8 Ops/sec
lodash omit	2981.8 Ops/sec

Related benchmarks:

omit vanilla vs. lodash (version: 0)

Comparing performance of: vanilla set vs vanilla object in vs vanilla object coerce vs vanilla array vs vanilla delete spread vs vanilla delete assign vs lodash omit

Created: 2 months ago by: Guest

Jump to the latest result

vanilla set

vanilla object in

vanilla object coerce

vanilla array

vanilla delete spread

vanilla delete assign

lodash omit

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):