Benchmark: Atlas - Lodash vs Native

HTML Preparation code:

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

Script Preparation code:

window.range = _.range(0, 500);

Tests:

Lodash each
const r = []; _.each(range, number => { r.push(number * number); });
Native forEach
const r = []; range.forEach(number => { r.push(number * number); });
Lodash map
const r = _.map(range, number => number * number);
Native map
const r = range.map(number => number * number);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash each
Native forEach
Lodash map
Native map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark called "Atlas - Lodash vs Native." This benchmark compares the performance of native JavaScript code versus code using the popular utility library, Lodash.

**Script Preparation Code**

The script preparation code is:
```javascript
window.range = _.range(0, 500);
```
This line creates an array `range` with 500 elements using the `_range` function from Lodash. The underscore prefix suggests that this is a custom implementation of the `range` function, which is then assigned to the global `window` object.

**Html Preparation Code**

The HTML preparation code is:
```html
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
```
This line includes the Lodash library in the HTML file, making its functions and methods available for use in the benchmark.

**Test Cases**

There are four test cases:

1. **Lodash each**
```javascript
_.each(range, number => {
  r.push(number * number);
});
```
This test case uses the `_each` function from Lodash to iterate over the `range` array and push the square of each element to an output array `r`.

2. **Native forEach**
```javascript
range.forEach(number => {
  r.push(number * number);
});
```
This test case uses the native `forEach` method to iterate over the `range` array and push the square of each element to an output array `r`. Note that this implementation is not optimized for performance.

3. **Lodash map**
```javascript
const r = _.map(range, number => number * number);
```
This test case uses the `_map` function from Lodash to create a new array with the square of each element in the `range` array and assigns it to an output variable `r`.

4. **Native map**
```javascript
const r = range.map(number => number * number);
```
This test case uses the native `map` method to create a new array with the square of each element in the `range` array and assigns it to an output variable `r`. Note that this implementation is not optimized for performance.

**Library: Lodash**

Lodash is a popular utility library for JavaScript that provides a wide range of functions for tasks such as:

* Array manipulation (e.g., `_each`, `_map`)
* String manipulation (e.g., `_stringStartsWith`)
* Object manipulation (e.g., `_assign`)
* Functionality extension (e.g., `_bindAll`)

Lodash's implementation of the `range` function is likely a custom version that returns an array with a specified number of elements.

**Special JS Feature: Arrow Functions**

The test cases use arrow functions, which are a shorthand syntax for defining small, anonymous functions. The syntax `number => { ... }` is equivalent to `function(number) { ... }`. Arrow functions were introduced in ECMAScript 2015 and provide a concise way to define small functions without the need for explicit `function` declarations.

**Benchmark Results**

The latest benchmark results show that:

* Native `forEach` has the highest performance (325,201.28125 executions per second)
* Lodash `map` has lower performance than native `map` (98,963.2265625 executions per second), but higher than native `forEach`
* Lodash `each` has lower performance than native `forEach` (27,999.263671875 executions per second)

Overall, the benchmark suggests that native JavaScript code can outperform Lodash's implementation of array iteration methods when it comes to performance. However, Lodash's implementations may provide additional benefits such as improved code readability and maintainability.

**Alternatives**

There are several alternatives to MeasureThat.net for creating and running JavaScript microbenchmarks:

* `js-bench`: A benchmarking framework that allows users to create and run microbenchmarks with a simple syntax.
* `benchmark.js`: A popular benchmarking library that provides a simple way to write and execute microbenchmarks.
* `fast-math-benchmark`: A benchmarking library that focuses on numerical computations and provides a wide range of benchmarks for various mathematical operations.

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

Browser/OS: Chrome 79 on Mac OS X 10.15.3

View result in a separate tab

Test name	Executions per second
Lodash each	98963.2 Ops/sec
Native forEach	325201.3 Ops/sec
Lodash map	135491.1 Ops/sec
Native map	27999.3 Ops/sec

Related benchmarks:

Atlas - Lodash vs Native (version: 0)

Comparing performance of: Lodash each vs Native forEach vs Lodash map vs Native map

Created: 6 years ago by: Guest

Jump to the latest result

Lodash each

Native forEach

Lodash map

Native map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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