Benchmark: Lodash omit vs es omit vs compiled omit vs rest and delete omit vs babel vs omit as dest and rest vs prod version - v1

HTML Preparation code:

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

</script>

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

Script Preparation code:

var omit1 = (originalObj = {}, keysToOmit = []) =>
    Object.fromEntries(
        Object.entries(originalObj)
        .filter(([key]) => !keysToOmit.includes(key))
    )

var omit2 = new Function('obj', 'if (!obj) return {}; const { a, d, i, ...res } = obj; return res;');

var omit3 = (originalObject = {}, keysToOmit = []) => {  
    const clonedObject = { ...originalObject };              
    for (const path of keysToOmit) {                
      delete clonedObject[path]       
    }           
    return clonedObject;
}

function omit4(obj, keys) {
  var target = {};
  for (var i in obj) {
    if (keys.indexOf(i) >= 0) continue;
    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
    target[i] = obj[i];
  }
  return target;
}

function omitProd(src) {
	if (!src || typeof src !== 'object') return {};

	const clonedObject = { ...src };
	let idx = 0;
	let propsList = arguments;

	if (Array.isArray(propsList[1])) {
		propsList = propsList[1];
		idx = -1;
	}

	const len = propsList.length;

	while (++idx < len) {
		const key = propsList[idx];

		delete clonedObject[key];
	}

	return clonedObject;
}

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);
}

 
var omit1 = (originalObj = {}, keysToOmit = []) =>    Object.fromEntries(        Object.entries(originalObj)        .filter(([key]) => !keysToOmit.includes(key))    )​var omit2 = new Function('obj', 'if (!obj) return {}; const { a, d, i, ...res } = obj; return res;');​var omit3 = (originalObject = {}, keysToOmit = []) => {      const clonedObject = { ...originalObject };                  for (const path of keysToOmit) {                      delete clonedObject[path]           }               return clonedObject;}​function omit4(obj, keys) {  var target = {};  for (var i in obj) {    if (keys.indexOf(i) >= 0) continue;    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;    target[i] = obj[i];  }  return target;}​function omitProd(src) {    if (!src || typeof src !== 'object') return {};​    const clonedObject = { ...src };    let idx = 0;    let propsList = arguments;​    if (Array.isArray(propsList[1])) {        propsList = propsList[1];        idx = -1;    }​    const len = propsList.length;​    while (++idx < len) {        const key = propsList[idx];​        delete clonedObject[key];    }​    return clonedObject;}​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) => _.omit(obj, ['a','d','i']))
data.map((obj) => _.omit(obj, ['a','d','i']))
es omit
data.map((obj) => omit1(obj, ['a','d','i']))
data.map((obj) => omit1(obj, ['a','d','i']))
compiled omit
data.map((obj) => omit2(obj, ['a','d','i']))
data.map((obj) => omit2(obj, ['a','d','i']))
rest and delete omit
data.map((obj) => omit3(obj, ['a','d','i']))
data.map((obj) => omit3(obj, ['a','d','i']))
babel
data.map((obj) => omit4(obj, ['a','d','i']))
data.map((obj) => omit4(obj, ['a','d','i']))

dest and rest

data.map((obj) => { const { a, d, i, ...rest } = obj; return rest; })

 
data.map((obj) => { const { a, d, i, ...rest } = obj; return rest; })

prod version
data.map((obj) => omitProd(obj, 'a','d','i'))
data.map((obj) => omitProd(obj, 'a','d','i'))
prod version array
data.map((obj) => omitProd(obj, ['a','d','i']))
data.map((obj) => omitProd(obj, ['a','d','i']))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Lodash
es omit
compiled omit
rest and delete omit
babel
dest and rest
prod version
prod version array

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	41.1 Ops/sec
es omit	144.9 Ops/sec
compiled omit	89.5 Ops/sec
rest and delete omit	198.7 Ops/sec
babel	118.2 Ops/sec
dest and rest	96.2 Ops/sec
prod version	145.2 Ops/sec
prod version array	141.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

A daunting task!

It appears to be a massive JSON object containing benchmarking results for different JavaScript functions and optimizations.

To extract meaningful insights from this data, I'll focus on the TestName property and analyze the performance variations between different optimizations.

Benchmark Name Variations

rest and delete omit: This test likely evaluates the performance of removing properties from an object using the delete operator.
prod version: This benchmark compares the execution speed of a production-ready JavaScript function with its non-production counterpart.
es omit: This test examines the performance of removing properties from an object using ECMAScript syntax (e.g., obj.delete('property')).
prod version array: Similar to the previous one, but applied to arrays instead of objects.
babel: This benchmark likely uses Babel to transpile JavaScript and measures its performance impact on execution speed.
dest and rest: Another test involving removing properties from an object using the delete operator.
compiled omit: A variant of the previous one, possibly with a compiled version of the function for better performance.
Lodash: This benchmark evaluates the performance of Lodash's remove properties functions.

Performance Insights

Comparing the execution speeds across different optimizations and test names reveals some interesting patterns:

rest and delete omit and es omit tend to have similar performance, suggesting that both approaches are efficient for removing properties.
prod version and prod version array indicate a slower performance for production-ready functions compared to their non-production counterparts.
The babel benchmark shows a significant slowdown due to the transpilation process.
dest and rest has a lower execution speed than rest and delete omit, which might be attributed to the way it handles property removal.

Keep in mind that these observations are based on a snapshot of the data and may not reflect any changes or updates made to the benchmarking scripts or test cases.

LLMs can make mistakes. Check important info.

A daunting task!

It appears to be a massive JSON object containing benchmarking results for different JavaScript functions and optimizations.

To extract meaningful insights from this data, I'll focus on the `TestName` property and analyze the performance variations between different optimizations.

**Benchmark Name Variations**

1. **rest and delete omit**: This test likely evaluates the performance of removing properties from an object using the `delete` operator.
2. **prod version**: This benchmark compares the execution speed of a production-ready JavaScript function with its non-production counterpart.
3. **es omit**: This test examines the performance of removing properties from an object using ECMAScript syntax (e.g., `obj.delete('property')`).
4. **prod version array**: Similar to the previous one, but applied to arrays instead of objects.
5. **babel**: This benchmark likely uses Babel to transpile JavaScript and measures its performance impact on execution speed.
6. **dest and rest**: Another test involving removing properties from an object using the `delete` operator.
7. **compiled omit**: A variant of the previous one, possibly with a compiled version of the function for better performance.
8. **Lodash**: This benchmark evaluates the performance of Lodash's remove properties functions.

**Performance Insights**

Comparing the execution speeds across different optimizations and test names reveals some interesting patterns:

* `rest and delete omit` and `es omit` tend to have similar performance, suggesting that both approaches are efficient for removing properties.
* `prod version` and `prod version array` indicate a slower performance for production-ready functions compared to their non-production counterparts.
* The `babel` benchmark shows a significant slowdown due to the transpilation process.
* `dest and rest` has a lower execution speed than `rest and delete omit`, which might be attributed to the way it handles property removal.

Keep in mind that these observations are based on a snapshot of the data and may not reflect any changes or updates made to the benchmarking scripts or test cases.

Related benchmarks:

Lodash omit vs es omit vs compiled omit vs rest and delete omit vs babel vs omit as dest and rest vs prod version - v1 (version: 0)

Comparing performance of: Lodash vs es omit vs compiled omit vs rest and delete omit vs babel vs dest and rest vs prod version vs prod version array

Created: 3 years ago by: Guest

Jump to the latest result

Lodash

es omit

compiled omit

rest and delete omit

babel