Benchmark: Lodash omit vs es omit vs compiled omit vs rest and delete omit vs babel - a lot of different objects

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 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 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']))

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4629.0 Safari/537.36 Edg/95.0.1011.1

Browser/OS: Chrome 95 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	28.8 Ops/sec
es omit	91.9 Ops/sec
compiled omit	56.3 Ops/sec
rest and delete omit	129.2 Ops/sec
babel	73.8 Ops/sec

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

I'll break down the test cases and explain what's being tested, along with their pros and cons.

Test Cases:

Lodash The benchmark tests the performance of Lodash's omit function, which removes specified properties from an object. The _.omit function is called for each object in the data array, passing an array of keys to omit (['a', 'd', 'i']). This test measures how fast Lodash can perform this operation.

Pros: Lodash is a widely-used and well-maintained library, so its implementation is likely efficient. Cons: Since it's a third-party library, there might be some overhead in loading and executing it.

es omit This benchmark tests the performance of a custom omit function implemented using ES6 syntax (notably, arrow functions and destructuring). The function takes an object and an array of keys to omit as arguments.

Pros: This implementation is likely to be efficient since it's written in native JavaScript. Cons: Since it's not part of a library or framework, there might be some overhead in loading and executing this code.

compiled omit This benchmark tests the performance of a custom omit function that has been compiled using a JavaScript compiler (in this case, possibly Babel). The function is similar to the ES6 implementation but uses a different syntax.

Pros: Compiling the code might improve its performance by optimizing the generated machine code. Cons: There's still some overhead in loading and executing the compiled code.

rest and delete omit This benchmark tests the performance of a custom omit function that uses rest properties (...) to extract the omitted properties and then deletes them from the original object using delete.

Pros: This implementation is likely to be efficient since it avoids creating new objects or arrays. Cons: It might not work in older browsers that don't support rest properties.

babel This benchmark tests the performance of a custom omit function implemented using Babel's syntax (notably, class expressions and arrow functions). The function takes an object and an array of keys to omit as arguments.

Library/ Framework Considerations:

Lodash: As mentioned earlier, Lodash is a widely-used and well-maintained library. Its implementation is likely efficient, but there might be some overhead in loading and executing it.
Babel: Babel is used to compile the custom omit functions, which might improve their performance by optimizing the generated machine code.

Additional Considerations:

The test cases are all running on the same environment (Chrome 95), so any differences in performance can be attributed to the implementation or library/framework being tested.
The benchmark is measuring the number of executions per second (ExecutionsPerSecond column), which gives an idea of how fast each implementation can process the data.

Overall, these test cases provide a good comparison between different implementations and libraries/frameworks for removing properties from objects.

LLMs can make mistakes. Check important info.

I'll break down the test cases and explain what's being tested, along with their pros and cons.

**Test Cases:**

1. **Lodash**
The benchmark tests the performance of Lodash's `omit` function, which removes specified properties from an object. The `_.omit` function is called for each object in the `data` array, passing an array of keys to omit (`['a', 'd', 'i']`). This test measures how fast Lodash can perform this operation.

Pros: Lodash is a widely-used and well-maintained library, so its implementation is likely efficient.
Cons: Since it's a third-party library, there might be some overhead in loading and executing it.

2. **es omit**
This benchmark tests the performance of a custom `omit` function implemented using ES6 syntax (notably, arrow functions and destructuring). The function takes an object and an array of keys to omit as arguments.

Pros: This implementation is likely to be efficient since it's written in native JavaScript.
Cons: Since it's not part of a library or framework, there might be some overhead in loading and executing this code.

3. **compiled omit**
This benchmark tests the performance of a custom `omit` function that has been compiled using a JavaScript compiler (in this case, possibly Babel). The function is similar to the ES6 implementation but uses a different syntax.

Pros: Compiling the code might improve its performance by optimizing the generated machine code.
Cons: There's still some overhead in loading and executing the compiled code.

4. **rest and delete omit**
This benchmark tests the performance of a custom `omit` function that uses rest properties (`...`) to extract the omitted properties and then deletes them from the original object using `delete`.

Pros: This implementation is likely to be efficient since it avoids creating new objects or arrays.
Cons: It might not work in older browsers that don't support rest properties.

5. **babel**
This benchmark tests the performance of a custom `omit` function implemented using Babel's syntax (notably, class expressions and arrow functions). The function takes an object and an array of keys to omit as arguments.

Pros: This implementation is likely to be efficient since it's written in native JavaScript.
Cons: Since it's not part of a library or framework, there might be some overhead in loading and executing this code.

**Library/ Framework Considerations:**

* Lodash: As mentioned earlier, Lodash is a widely-used and well-maintained library. Its implementation is likely efficient, but there might be some overhead in loading and executing it.
* Babel: Babel is used to compile the custom `omit` functions, which might improve their performance by optimizing the generated machine code.

**Additional Considerations:**

* The test cases are all running on the same environment (Chrome 95), so any differences in performance can be attributed to the implementation or library/framework being tested.
* The benchmark is measuring the number of executions per second (`ExecutionsPerSecond` column), which gives an idea of how fast each implementation can process the data.

Overall, these test cases provide a good comparison between different implementations and libraries/frameworks for removing properties from objects.

Related benchmarks:

Lodash omit vs es omit vs compiled omit vs rest and delete omit vs babel - a lot of different objects (version: 0)

Comparing performance of: Lodash vs es omit vs compiled omit vs rest and delete omit vs babel

Created: 3 years ago by: Guest

Jump to the latest result

Lodash

es omit

compiled omit

rest and delete omit

babel

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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