Benchmark: Lodash pick vs native pick vs compiled fn pick vs native pick (own) vs compiled (own)

HTML Preparation code:

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

Script Preparation code:

function pick1(obj, keys) {

  var res = {};
  if (typeof keys === 'string') {
    if (keys in obj) {
      res[keys] = obj[keys];
    }
    return res;
  }

  var len = keys.length;
  var idx = -1;

  while (++idx < len) {
    var key = keys[idx];
    if (key in obj) {
      res[key] = obj[key];
    }
  }
  return res;
};

var pick2 = new Function('el', 'if (!el) return {};  const res = {}; ' + 
                         'if ("a" in el) res.a = el.a;' + 
                         'if ("d" in el) res.d = el.d;' + 
                         'if ("i" in el) res.i = el.i;' + 
                         ' return res;')


function pick3(obj, keys) {
  const hasOwn = Object.prototype.hasOwnProperty;
  var res = {};
  if (typeof keys === 'string') {
    if (hasOwn.call(obj, keys)) {
      res[keys] = obj[keys];
    }
    return res;
  }

  var len = keys.length;
  var idx = -1;

  while (++idx < len) {
    var key = keys[idx];
    if (hasOwn.call(obj, keys)) {
      res[key] = obj[key];
    }
  }
  return res;
};

var pick4 = new Function('el', 'if (!el) return {};  const hasOwn = Object.prototype.hasOwnProperty; const res = {}; ' + 
                         'if (hasOwn.call(el, "a")) res.a = el.a;' + 
                         'if (hasOwn.call(el, "d")) res.d = el.d;' + 
                         'if (hasOwn.call(el, "i")) res.i = el.i;' + 
                         ' return res;')

function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min) + min); //The maximum is exclusive and the minimum is inclusive
}


var data = [];

for (let i = 0; i < 10000; i++) {
    const obj = {};
	const propsCount = getRandomInt(0, 10);
  
  	for (let j = 0; j < propsCount; j++) {
		
	 	const propCode = getRandomInt(97, 122);
      
  		obj[String.fromCharCode(propCode)] = propCode;
	}
  
    data.push(obj);
}

Tests:

Lodash
data.map((obj) => _.pick(obj, ['a','d','i']))
native pick
data.map((obj) => pick1(obj, ['a','d','i']))
compiled function
data.map((obj) => pick2(obj, ['a','d','i']))
native pick (own)
data.map((obj) => pick3(obj, ['a','d','i']))
compiled (own)
data.map((obj) => pick4(obj, ['a','d','i']))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
native pick
compiled function
native pick (own)
compiled (own)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark, its options, and pros/cons.

**What is tested?**

MeasureThat.net is testing four different approaches to extract specific properties from objects:

1. **Lodash (`_.pick(obj, ['a','d','i'])`)**: Using the popular JavaScript utility library Lodash, which provides a `pick` function that extracts a subset of properties from an object.
2. **Native pick (`data.map((obj) => pick1(obj, ['a','d','i']))`)**: Implementing a native JavaScript function `pick1` that iterates through the keys and checks if each key exists in the object before assigning it to a new object.
3. **Compiled function (`data.map((obj) => pick2(obj, ['a','d','i'])`)**: Creating a compiled function using the `new Function()` constructor, which generates JavaScript code on the fly based on the provided arguments and properties to extract.
4. **Native pick (own)` (`data.map((obj) => pick3(obj, ['a','d','i']))`)**: Similar to native pick, but with a slight variation in the implementation.
5. **Compiled (own)` (`data.map((obj) => pick4(obj, ['a','d','i'])`)**: Similar to compiled function, but using a different implementation.

**Options comparison**

The options being compared are:

* Speed and performance
* Code size and complexity
* Memory usage

**Pros/Cons of each approach**

1. **Lodash (`_.pick(obj, ['a','d','i'])`)**:
	* Pros: Fast, easy to use, well-maintained library.
	* Cons: Adds dependency on Lodash, may not be suitable for all use cases (e.g., Node.js builds).
2. **Native pick (`data.map((obj) => pick1(obj, ['a','d','i']))`)**:
	* Pros: Fast, no dependencies, can be optimized for specific use cases.
	* Cons: Requires manual implementation, may have performance issues if not optimized correctly.
3. **Compiled function (`data.map((obj) => pick2(obj, ['a','d','i'])`)**:
	* Pros: Fast, can be optimized for specific use cases, generates compact code.
	* Cons: May have performance overhead due to dynamic compilation, dependencies on JavaScript engine capabilities.
4. **Native pick (own)` (`data.map((obj) => pick3(obj, ['a','d','i']))`)**:
	* Pros: Similar to native pick, with minor variations in implementation.
	* Cons: Same pros/cons as native pick, but with slightly different code.
5. **Compiled (own)` (`data.map((obj) => pick4(obj, ['a','d','i'])`)**:
	* Pros: Similar to compiled function, with minor variations in implementation.
	* Cons: Same pros/cons as compiled function, but with slightly different code.

**Benchmark results**

The latest benchmark results show that:

* Lodash is the fastest option, followed closely by native pick and compiled (own) functions.
* Compiled function is slower than native pick, despite its compact code size.
* Native pick (own) has similar performance to native pick, but with slightly different execution frequencies.

Keep in mind that these results may vary depending on specific use cases, hardware configurations, and JavaScript engine versions.

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/98.0.4758.102 Safari/537.36

Browser/OS: Chrome 98 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	64.9 Ops/sec
native pick	409.2 Ops/sec
compiled function	348.8 Ops/sec
native pick (own)	55.9 Ops/sec
compiled (own)	419.1 Ops/sec

Related benchmarks:

Lodash pick vs native pick vs compiled fn pick vs native pick (own) vs compiled (own) (version: 0)

Comparing performance of: Lodash vs native pick vs compiled function vs native pick (own) vs compiled (own)

Created: 3 years ago by: Guest

Jump to the latest result

Lodash

native pick

compiled function

native pick (own)

compiled (own)

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