Benchmark: Lodash Object/Array map 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:

const obj = {
    '1':    1,
    '2':    2,
    '3':    3,
    '4':    4,
    '5':    5,
    '6':    6,
    '7':    7,
    '8':    8,
    '9':    9,
    '10':   10,
    '11':   11,
    '12':   12,
    '13':   13
}

function mapper(el) {
 return el + 10
}
function lodashObjectMap () {
  res = _.map(obj, mapper)
  console.log(res)
}

function jsValuesMap () {
  res = Object.values(obj).map(mapper)
  console.log(res)
}

const arr = [1,2,3,4,5,6,7,8,9,10,11,12,13]

function lodashArrayMap() {
  res = _.map(arr, mapper)
  console.log(res)
}

function jsMap(){
  res = arr.map(mapper)
  console.log(res)
}

Tests:

Native Object Map
jsValuesMap()
Lodash Object Map
lodashObjectMap()
js Map
jsMap()
lodash Array Map
lodashArrayMap()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native Object Map
Lodash Object Map
js Map
lodash Array Map

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 98 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Native Object Map	61289.3 Ops/sec
Lodash Object Map	60031.9 Ops/sec
js Map	61377.8 Ops/sec
lodash Array Map	69487.0 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark test case by test case.

**Benchmark Definition:**
The test cases are comparing the performance of two different approaches to map over objects and arrays using JavaScript's built-in functions or a popular utility library called Lodash.

**Individual Test Cases:**

1. **Native Object Map (jsValuesMap())**
This test case uses JavaScript's native `Object.values()` method, which returns an array of a given object's values. The `map()` function is then applied to this array using the provided `mapper` function.
	* What is tested: Native JavaScript performance for mapping over an object's values.
	* Pros: Built-in functions are generally faster and more efficient than external libraries.
	* Cons: May not be as feature-rich or convenient as library-based solutions.
2. **Lodash Object Map (lodashObjectMap())**
This test case uses the Lodash library's `map()` function to iterate over an object, applying a callback function (`mapper`) to each value.
	* What is tested: Performance of using a popular utility library like Lodash for mapping over objects.
	* Pros: Library-based solutions can provide more features and convenience than native JavaScript functions.
	* Cons: May introduce additional overhead due to library loading and usage.
3. **js Map (jsMap())**
This test case simply uses the built-in `map()` function on an array, applying a callback function (`mapper`) to each element.
	* What is tested: Native JavaScript performance for mapping over arrays.
	* Pros: Built-in functions are generally faster and more efficient than external libraries.
	* Cons: May not be as feature-rich or convenient as library-based solutions.
4. **Lodash Array Map (lodashArrayMap())**
This test case uses the Lodash library's `map()` function to iterate over an array, applying a callback function (`mapper`) to each element.
	* What is tested: Performance of using a popular utility library like Lodash for mapping over arrays.
	* Pros: Library-based solutions can provide more features and convenience than native JavaScript functions.
	* Cons: May introduce additional overhead due to library loading and usage.

**Library Used:**
Lodash (https://lodash.com/) is a popular, lightweight JavaScript utility library that provides various functional programming helpers, including `map()`, `filter()`, and more. It's often used for convenience, readability, and consistency in codebases.

**JS Feature or Syntax Used:**
The test cases use JavaScript's built-in functions, such as `Object.values()` and `map()`. These features are part of the ECMAScript standard and are widely supported across browsers and environments.

**Other Alternatives:**
Some alternatives to these approaches could be:

* Using other utility libraries like Underscore (http://underscorejs.org/) or Ramda (https://ramdajs.com/).
* Implementing custom mapping functions for specific use cases.
* Leveraging modern JavaScript features, such as `Array.prototype.flatMap()` or `Map.prototype.forEach()`.
* Using asynchronous approaches, like Promise-based `map` functions.

Keep in mind that these alternatives might have their own trade-offs and implications on performance.

Related benchmarks:

Lodash Object/Array map vs native (version: 0)

Comparing performance of: Native Object Map vs Lodash Object Map vs js Map vs lodash Array Map

Created: 2 years ago by: Guest

Jump to the latest result

Native Object Map

Lodash Object Map

js Map

lodash Array Map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):