Benchmark: lodash pick vs omit vs my stuff

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@3.10.0/index.min.js"></script>

Script Preparation code:

var a = {
  foo: "foo",
  bar: undefined,
  do: 'test',
  egg: 'egg' 
};

Tests:

extra stuff
const keys = Object.keys(a); const filter = keys.filter((e) => e !== 'id'); const result = _.pick(a, filter);
pick
_.pick(a, _.identity)
omit
_.omit(a, ['id'])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
extra stuff
pick
omit

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and explore what's being tested in this benchmark.

**Overview**

The benchmark compares three different approaches to pick (select) and omit (exclude) properties from an object: using Lodash's `pick` function, using Lodash's `omit` function, and implementing a custom solution ("my stuff").

**Lodash: Pick and Omit Functions**

Lodash is a popular JavaScript library that provides a wide range of useful functions for working with data. The `pick` and `omit` functions are two of its most commonly used functions.

* `_.pick(a, filter)`: This function takes an object `a` and an array of keys to include in the resulting object. It returns a new object that only includes the properties specified by the `filter` array.
* `_.omit(a, [key1, key2, ...])`: This function takes an object `a` and an array of keys to exclude from the resulting object. It returns a new object that excludes the properties specified by the `key` array.

In the benchmark, both functions are used with different arrays of keys: `_.pick(a, filter)` uses an array of keys that includes "foo", "bar", "do", and "egg" but excludes "id", while `_.omit(a, ['id'])` uses a single key "id".

**Custom Solution ("my stuff")**

The custom solution is not shown in the benchmark definition, but it's likely to be implemented using a similar approach as Lodash's `pick` and `omit` functions. This would involve iterating over the object's properties and selecting or excluding them based on some criteria.

**Pros and Cons of Each Approach**

Here are some pros and cons of each approach:

* **Lodash: Pick Function**
	+ Pros:
		- Highly optimized and efficient
		- Easy to use and understand
		- Well-tested and widely adopted
	+ Cons:
		- May have dependencies on other Lodash functions or modules
		- May not be suitable for very large objects due to performance concerns
* **Lodash: Omit Function**
	+ Pros:
		- Highly optimized and efficient
		- Easy to use and understand
		- Well-tested and widely adopted
	+ Cons:
		- May have dependencies on other Lodash functions or modules
		- May not be suitable for very large objects due to performance concerns
* **Custom Solution ("my stuff")**
	+ Pros:
		- Can be highly optimized and efficient depending on the implementation
		- Allows for custom logic and behavior
	+ Cons:
		- May require more code and expertise to implement correctly
		- May have performance issues if not implemented carefully

**Other Considerations**

* **Performance**: The benchmark measures execution time, which is an important consideration when choosing a function or approach. Lodash's `pick` and `omit` functions are optimized for performance, but the custom solution may need to be carefully implemented to achieve similar performance.
* **Code Readability and Maintainability**: The use of Lodash's `pick` and `omit` functions makes it easy to understand and maintain the code, as these functions are well-documented and widely adopted. A custom solution would require more expertise and documentation to ensure readability and maintainability.

**Alternatives**

Other alternatives for picking and omitting properties from an object include:

* Using the `Object.keys()` method and iterating over the resulting array to select or exclude properties.
* Using a library like Moment.js, which provides a similar function called `omit`.
* Implementing a custom solution using a different programming paradigm, such as functional programming.

However, Lodash's `pick` and `omit` functions are widely adopted and well-maintained, making them a popular choice for many developers.

Latest run results:

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

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

Browser/OS: Chrome 96 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
extra stuff	1335874.1 Ops/sec
pick	1481971.8 Ops/sec
omit	1477281.0 Ops/sec

Related benchmarks:

lodash pick vs omit vs my stuff (version: 0)

Comparing performance of: extra stuff vs pick vs omit

Created: 2 years ago by: Guest

Jump to the latest result

extra stuff

pick

omit

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):