Benchmark: _Mhai's Code2 - MeasureThat.net

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.core.js"></script>

Script Preparation code:

var data = {
    'member_info_decrypt': []
};

for (var i=0;i<100000;i++) {
  data['member_info_decrypt'][i] = {
    'firebase_id': ''+i,
    'member_id': ''+i,
    'mobile_no': ''+i,
  }
}

Tests:

MhaiCode
_.map(data.member_info_decrypt, object => { return _.pick(object, ['firebase_id', 'member_id', 'mobile_no']) })
Native1
const items = data.member_info_decrypt; items.map(({firebase_id,member_id,mobile_no})=>({firebase_id,member_id,mobile_no}))
Native2
const items = data.member_info_decrypt; const length = items.length; const result = []; for(var i=0; i<length; i++) { const {firebase_id,member_id,mobile_no} = items[i]; result[i] = { firebase_id,member_id,mobile_no } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
MhaiCode
Native1
Native2

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36

Browser/OS: Chrome 87 on Linux

View result in a separate tab

Test name	Executions per second
MhaiCode	11.6 Ops/sec
Native1	74.5 Ops/sec
Native2	378.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested on the provided JSON.

**Benchmark Definition**

The benchmark aims to compare three approaches for mapping over an array and extracting specific properties:

1. **Lodash `.map()` method**: Uses the `_.map()` function from Lodash, a utility library that provides functional programming helpers.
2. **Native JavaScript `.map()` method without arrow functions**: A plain JavaScript implementation of the `.map()` method using a traditional loop.
3. **Native JavaScript `.map()` method with arrow functions**: A modified version of the previous approach using arrow functions.

**Options Compared**

The benchmark compares:

* Lodash's `.map()` function vs. the native JavaScript `.map()` method without arrow functions
* The native JavaScript `.map()` method without arrow functions vs. the native JavaScript `.map()` method with arrow functions

**Pros and Cons of Each Approach**

1. **Lodash `.map()`**: Pros:
	* Faster, as it's a specialized library optimized for performance.
	* Easier to read and maintain, thanks to its functional programming style.
2. **Native JavaScript `.map()` without arrow functions**: Pros:
	* Still performs well, but may be slower than Lodash due to the overhead of the traditional loop.
	* Familiarity with standard JavaScript syntax can make it easier to understand and implement.
3. **Native JavaScript `.map()` with arrow functions**: Pros:
	* Combines the speed of the native method with the readability of arrow functions.
	* Reduces boilerplate code, making it more concise.

Cons:

* Arrow functions may not be supported in older browsers or environments.

**Library Used: Lodash**

Lodash is a popular JavaScript utility library that provides various functional programming helpers. In this benchmark, Lodash's `.map()` function is used to compare the performance of mapping over an array with different approaches.

**Special JS Feature/ Syntax: Arrow Functions**

Arrow functions are a feature introduced in ECMAScript 2015 (ES6). They provide a concise syntax for defining small, single-expression functions. In this benchmark, arrow functions are used in the native JavaScript `.map()` method to improve readability and reduce boilerplate code.

**Other Alternatives**

If you need to map over an array and extract specific properties, other alternatives could include:

* **ES6 template literals**: Could be used as a more concise alternative to string concatenation.
* **Modern JavaScript array methods**: Such as `forEach()` or `filter()`, which may have different performance characteristics compared to `.map()`.

Keep in mind that the choice of approach depends on your specific use case, performance requirements, and personal preference.

Related benchmarks:

_Mhai's Code2 (version: 0)

Compare the new ES6 spread operator with the traditional concat() method

Comparing performance of: MhaiCode vs Native1 vs Native2

Created: 3 years ago by: Guest

Jump to the latest result

MhaiCode

Native1

Native2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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