Benchmark: _.chain.pick.value vs _.pick

HTML Preparation code:

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

Script Preparation code:

var obj = {
    one: 1,
    two: 2,
    three: {
        a: '3.a',
        b: '3.b'
    }
};

var keys = ['one', 'three'];

Tests:

_.chain(obj).pick(keys).value()
let result = _.chain(obj).pick(keys).value();
_.pick(obj, keys)
let result = _.pick(obj, keys);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.chain(obj).pick(keys).value()
_.pick(obj, keys)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.chain(obj).pick(keys).value()	2037799.5 Ops/sec
_.pick(obj, keys)	2500007.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**What is being tested?**

The benchmark compares two ways to select specific values from an object using Lodash, a popular JavaScript utility library.

**Options compared:**

1. **_.chain() + _.pick()**: This method chain uses `_.chain()` to wrap the original object in a new object that allows for chaining of methods. It then calls `_pick()` to filter out properties based on the provided keys array.
2. **_.pick()**: This is a standalone function from Lodash that takes an object and an array of keys as arguments, returning a new object with only the specified keys.

**Pros and Cons:**

* _.chain() + _.pick():
	+ Pros:
		- Can be more flexible for complex filtering scenarios.
		- Allows for chaining multiple methods on the filtered object.
	+ Cons:
		- Adds overhead due to creating a new object wrapper.
		- May incur additional memory allocation and garbage collection.
* _.pick():
	+ Pros:
		- Faster, as it only requires passing an array of keys to the function.
		- More lightweight, with fewer memory allocations.
	+ Cons:
		- Less flexible for complex filtering scenarios.

**Other considerations:**

Both methods return a new object without modifying the original. However, the `_chain()` method returns an object that can be further chained, while `_pick()` directly returns the filtered values. This might affect performance depending on how you plan to use the results.

**Library: Lodash (version 4.17.5)**

Lodash is a widely used JavaScript utility library that provides a set of functional programming helpers. In this benchmark, Lodash's `chain` and `pick` functions are used to filter and select values from objects.

There are no special JavaScript features or syntax being tested in this benchmark. Both methods rely on standard JavaScript object manipulation techniques.

**Alternatives:**

If you're looking for alternatives to Lodash, consider the following:

* **Underscore.js**: Another popular utility library that provides similar functionality.
* **Built-in JavaScript object methods**: You can use `Object.keys()`, `Object.values()`, and `Array.prototype.filter()` to achieve similar results without relying on external libraries.

Note that while these alternatives might be viable, they may not provide the same level of flexibility or convenience as Lodash's chainable functions.

Related benchmarks:

_.chain.pick.value vs _.pick (version: 0)

Comparing performance of: _.chain(obj).pick(keys).value() vs _.pick(obj, keys)

Created: one year ago by: Guest

Jump to the latest result

_.chain(obj).pick(keys).value()

_.pick(obj, 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):