Benchmark: Lodash vs Javascript Preliminary Work 3

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>

Script Preparation code:

var max1 = 100000; // 100,000 (100 Thousand)
var max2 = 10000000; // 10,000,000 (10 Million)
 

var intArr1 = [];
var strArr1 = [];
for (var i = 0; i <= max1; i++) { intArr1.push(i); }
for (var i = 0; i <= max1; i++) { strArr1.push('ABCDE'); }


var intArr2 = [];
var strArr2 = [];

for (var i = 0; i <= max2; i++) { intArr2.push(i); }
for (var i = 0; i <= max2; i++) { strArr2.push('ABCDE'); }

Tests:

Native Int Small
intArr1.forEach(function (element, index) { element = element*2; });
Native Int Large
intArr2.forEach(function (element, index) { element = element*2; });
Lodash Int Small
_.forEach(intArr1, function (element, index) { element = element*2; });
Lodash Int Large
_.forEach(intArr2, function (element, index) { element = element*2; });
Native Str Small
strArr1.forEach(function (element, index) { element = element*2; });
Native Str Large
strArr2.forEach(function (element, index) { element = element*2; });
Lodash Str Small
_.forEach(strArr1, function (element, index) { element = element*2; });
Lodash Str Large
_.forEach(strArr2, function (element, index) { element = element*2; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native Int Small
Native Int Large
Lodash Int Small
Lodash Int Large
Native Str Small
Native Str Large
Lodash Str Small
Lodash Str Large

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON defines two benchmark definitions: one for testing the performance of Lodash and another for testing the performance of native JavaScript (preliminary work) with three different test cases each.

**Benchmark Definition**

The first benchmark definition tests the performance of Lodash's `forEach` function on an array of integers and strings. The second benchmark definition tests the performance of native JavaScript's `forEach` function on two arrays: one with 100,000 integers and another with 10,000,000 integers.

**Test Cases**

There are six test cases in total:

1. **Native Int Small**: Tests native JavaScript's `forEach` function on an array of 100,000 integers.
2. **Native Int Large**: Tests native JavaScript's `forEach` function on an array of 10,000,000 integers.
3. **Lodash Int Small**: Tests Lodash's `forEach` function on an array of 100,000 integers.
4. **Lodash Int Large**: Tests Lodash's `forEach` function on an array of 10,000,000 integers.
5. **Native Str Small**: Tests native JavaScript's `forEach` function on an array of 100,000 strings.
6. **Lodash Str Small**: Tests Lodash's `forEach` function on an array of 100,000 strings.

**Library**

The provided HTML preparation code includes a reference to the Lodash library version 4.17.4. Lodash is a popular JavaScript utility library that provides a set of high-order functions for tasks such as array manipulation, functional programming, and more.

**JavaScript Features/Syntax**

None of the benchmark definitions use special JavaScript features or syntax. They only rely on standard JavaScript functionality.

**Performance Comparison**

The provided benchmark results show the performance of native JavaScript's `forEach` function versus Lodash's `forEach` function for each test case. The results suggest that native JavaScript's `forEach` function is generally faster than Lodash's `forEach` function, especially for larger arrays.

Here are some key takeaways from the benchmark results:

* Native JavaScript's `forEach` function is consistently faster than Lodash's `forEach` function.
* The performance difference decreases as the array size increases.
* Lodash's `forEach` function is slower due to the overhead of calling a higher-order function (the `forEach` function itself).
* Native JavaScript's `forEach` function has lower memory usage compared to Lodash's `forEach` function.

Keep in mind that these results are specific to this particular benchmark and may not generalize to all scenarios or use cases.

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

Browser/OS: Chrome 107 on Windows

View result in a separate tab

Test name	Executions per second
Native Int Small	515.9 Ops/sec
Native Int Large	4.9 Ops/sec
Lodash Int Small	626.8 Ops/sec
Lodash Int Large	6.2 Ops/sec
Native Str Small	132.4 Ops/sec
Native Str Large	1.4 Ops/sec
Lodash Str Small	142.5 Ops/sec
Lodash Str Large	1.4 Ops/sec

Related benchmarks:

Lodash vs Javascript Preliminary Work 3 (version: 0)

A set of simple tests to examine the performance of the two tools

Comparing performance of: Native Int Small vs Native Int Large vs Lodash Int Small vs Lodash Int Large vs Native Str Small vs Native Str Large vs Lodash Str Small vs Lodash Str Large

Created: 2 years ago by: Registered User

Jump to the latest result

Native Int Small

Native Int Large

Lodash Int Small

Lodash Int Large

Native Str Small

Native Str Large

Lodash Str Small

Lodash Str Large

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