Benchmark: Lodash vs Native vs For loop

HTML Preparation code:

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

Script Preparation code:

window.arr = [{
	key : 'pier',
	object : 'organization',
	path : 'customAttributes',
	fullPath : 'customAttributes.pier',
	dataType : 'string',
	label : 'label',
	filterable : false,
	searchable : true,
	sortable : true,
	writable : true,
	custom : true,
	archived : false
}, {
	key : 'batang-pier',
	object : 'organization',
	path : 'customAttributes',
	fullPath : 'customAttributes.pier',
	dataType : 'string',
	label : 'label',
	filterable : false,
	searchable : true,
	sortable : true,
	writable : true,
	custom : true,
	archived : true
}, {
	key : 'global-port',
	object : 'organization',
	path : 'customAttributes',
	fullPath : 'customAttributes.pier',
	dataType : 'string',
	label : 'label',
	filterable : false,
	searchable : true,
	sortable : true,
	writable : true,
	custom : true,
	archived : false
}]

Tests:

Lodash
var result = _.reduce(arr, function(result, attribute) { if (!attribute.archived) { result[attribute.key] = attribute; } return result; }, {}) console.log(result)
Native
var result = arr.reduce(function(result, attribute) { if (!attribute.archived) { result[attribute.key] = attribute; } return result; }, {}); console.log(result)
For Loop
const result = {}; for (let i = 0; i < arr.length; i++) { const attribute = arr[i]; if (!attribute.archived) { result[attribute.key] = attribute; } } console.log(result)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Native
For Loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a benchmark test case for comparing the performance of Lodash, native JavaScript, and a for loop in filtering an array of objects.

**Benchmark Definition**

The test case defines three different approaches:

1. **Lodash**: The `_.reduce()` method is used to filter the array of objects. This approach relies on the Lodash library.
2. **Native**: A native JavaScript implementation uses the `reduce()` method to filter the array of objects. This approach does not rely on any external libraries.
3. **For Loop**: A traditional for loop is used to iterate through the array of objects and filter out the ones marked as archived.

**Options Comparison**

The three approaches have different pros and cons:

* **Lodash**: Pros:
	+ Simplifies the filtering logic, making it easier to read and maintain.
	+ Provides a consistent and predictable output.
	Cons:
	+ Requires the Lodash library to be included in the test environment.
	+ May not optimize well for very large arrays or complex filtering conditions.
* **Native**: Pros:
	+ Does not rely on any external libraries, making it more lightweight and efficient.
	+ Can potentially optimize better for large arrays or complex filtering conditions.
Cons:
	+ Requires manual implementation of the filtering logic, which can be error-prone and harder to maintain.
	+ May not provide a consistent or predictable output without proper testing.
* **For Loop**: Pros:
	+ Does not rely on any external libraries or syntax, making it more portable and easier to understand.
Cons:
	+ Requires manual implementation of the filtering logic, which can be error-prone and harder to maintain.
	+ May not optimize well for large arrays or complex filtering conditions.

**Library - Lodash**

Lodash is a popular JavaScript library that provides a collection of helper functions for common tasks, including array manipulation. In this test case, the `_.reduce()` method is used to filter the array of objects. The Lodash library provides a consistent and predictable output, making it easier to reason about the behavior of the code.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this test case. However, the use of the `_.reduce()` method from Lodash is worth noting as a feature that allows for concise and expressive filtering logic.

**Other Alternatives**

In addition to the three approaches mentioned above, other alternatives could be considered:

* Using `Array.prototype.filter()` or `Array.prototype.map()` methods instead of `reduce()`.
* Utilizing more advanced JavaScript features such as arrow functions, destructuring, or template literals for improved readability and conciseness.
* Leveraging modern JavaScript libraries or frameworks that provide optimized array manipulation and filtering functionality.

In summary, the test case compares the performance of three approaches to filter an array of objects: Lodash, native JavaScript, and a for loop. Each approach has its pros and cons, and the choice of which one to use depends on the specific requirements and constraints of the project.

Latest run results:

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

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

Browser/OS: Chrome 80 on Mac OS X 10.15.3

View result in a separate tab

Test name	Executions per second
Lodash	49538.4 Ops/sec
Native	50513.1 Ops/sec
For Loop	46276.4 Ops/sec

Related benchmarks:

Lodash vs Native vs For loop (version: 1)

Comparing performance of: Lodash vs Native vs For Loop

Created: 4 years ago by: Registered User

Jump to the latest result

Lodash

Native

For Loop

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