Benchmark: lodash omit vs spread omit using babel

HTML Preparation code:

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

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

Tests:

lodash omit

const a = { aa: 'oh', bb: 'my' };
const b = _.omit(a, 'aa');

 
const a = { aa: 'oh', bb: 'my' };const b = _.omit(a, 'aa');

spread as compiled by babel

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

var a = {
  aa: 'oh',
  bb: 'my'
};

var aa = a.aa,
    b = _objectWithoutProperties(a, ["aa"]);

​x
 
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }​function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }​var a = {  aa: 'oh',  bb: 'my'};​var aa = a.aa,    b = _objectWithoutProperties(a, ["aa"]);

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 omit
spread as compiled by babel

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 76 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
lodash omit	563338.6 Ops/sec
spread as compiled by babel	1328902.6 Ops/sec

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

Let's break down the provided JSON data to understand what's being tested.

Benchmark Definition

The benchmark measures the performance of two approaches:

Lodash omit: This test case uses Lodash, a popular JavaScript utility library, to omit specific keys from an object. The test creates an object a with two properties: aa and bb. It then calls _omit function on this object, passing 'aa' as the excluded key.
Spread operator (compiled by Babel): This test case uses the spread operator ({...}) to create a new object that excludes specific keys from the original object a.

Options Compared

The two options being compared are:

Lodash omit: A library-based approach that uses Lodash's implementation of the omit function.
Spread operator (compiled by Babel): A native JavaScript approach that uses the spread operator to create a new object with omitted keys.

Pros and Cons

Lodash omit

Pros:

Well-tested and optimized implementation of the omit function
May be faster for large objects due to caching and memoization

Cons:

Adds an extra dependency on Lodash, which may not be desirable for all projects
May have a higher memory footprint due to the additional library overhead

Spread operator (compiled by Babel)

Pros:

Native JavaScript implementation with minimal dependencies
No additional library overhead
Often faster and more efficient than library-based approaches

Cons:

May require additional configuration or compilation steps for optimal performance
Can be less readable or maintainable due to its concise syntax

Library: Lodash

Lodash is a popular JavaScript utility library that provides a wide range of functions, including omit, map, filter, and many others. Its implementation is highly optimized and tested, making it a reliable choice for many use cases.

Special JS Feature/Syntax: None mentioned

There are no special JavaScript features or syntax being used in these test cases.

Other Alternatives

For the omit function, other alternatives include:

Using a custom implementation in JavaScript
Using a different library (e.g., Underscore.js)
Using a functional programming approach with higher-order functions

For the spread operator, other alternatives include:

Using a different syntax (e.g., Object.assign() or Array.prototype.slice())
Compiling the spread operator to a native JavaScript implementation using tools like Babel
Using a library-based approach (e.g., Lodash's omit function)

In general, the choice of approach depends on the specific use case, performance requirements, and personal preference.

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data to understand what's being tested.

**Benchmark Definition**

The benchmark measures the performance of two approaches:

1. **Lodash `omit`**: This test case uses Lodash, a popular JavaScript utility library, to omit specific keys from an object. The test creates an object `a` with two properties: `aa` and `bb`. It then calls `_omit` function on this object, passing `'aa'` as the excluded key.
2. **Spread operator (compiled by Babel)**: This test case uses the spread operator (`{...}`) to create a new object that excludes specific keys from the original object `a`.

**Options Compared**

The two options being compared are:

1. **Lodash `omit`**: A library-based approach that uses Lodash's implementation of the `omit` function.
2. **Spread operator (compiled by Babel)**: A native JavaScript approach that uses the spread operator to create a new object with omitted keys.

**Pros and Cons**

**Lodash `omit`**

Pros:

* Well-tested and optimized implementation of the `omit` function
* May be faster for large objects due to caching and memoization

Cons:

* Adds an extra dependency on Lodash, which may not be desirable for all projects
* May have a higher memory footprint due to the additional library overhead

**Spread operator (compiled by Babel)**

Pros:

* Native JavaScript implementation with minimal dependencies
* No additional library overhead
* Often faster and more efficient than library-based approaches

Cons:

* May require additional configuration or compilation steps for optimal performance
* Can be less readable or maintainable due to its concise syntax

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions, including `omit`, `map`, `filter`, and many others. Its implementation is highly optimized and tested, making it a reliable choice for many use cases.

**Special JS Feature/Syntax: None mentioned**

There are no special JavaScript features or syntax being used in these test cases.

**Other Alternatives**

For the `omit` function, other alternatives include:

* Using a custom implementation in JavaScript
* Using a different library (e.g., Underscore.js)
* Using a functional programming approach with higher-order functions

For the spread operator, other alternatives include:

* Using a different syntax (e.g., `Object.assign()` or `Array.prototype.slice()`)
* Compiling the spread operator to a native JavaScript implementation using tools like Babel
* Using a library-based approach (e.g., Lodash's `omit` function)

In general, the choice of approach depends on the specific use case, performance requirements, and personal preference.

Related benchmarks:

lodash omit vs spread omit using babel (version: 0)

Comparing performance of: lodash omit vs spread as compiled by babel

Created: 5 years ago by: Guest

Jump to the latest result

lodash omit

spread as compiled by 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):