Benchmark: _Mhai's Code - 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': [{
            'firebase_id': '1',
            'member_id': '1',
            'mobile_no': '1',
        },
        {
            'firebase_id': '2',
            'member_id': '2',
            'mobile_no': '2',
        },
        {
            'firebase_id': '3',
            'member_id': '3',
            'mobile_no': '3',
        }
    ]
};

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 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36

Browser/OS: Chrome 88 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
MhaiCode	539095.8 Ops/sec
Native1	9509521.0 Ops/sec
Native2	8813064.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Purpose**

The benchmark is designed to compare the performance of three approaches for transforming an array of objects in JavaScript:

1. Using the `_.map()` function from the Lodash library (specifically, `.pick()`).
2. Using a traditional `for` loop.
3. Using the spread operator (`...`) with object destructuring.

**Options Compared**

The benchmark compares the performance of these three approaches on a dataset containing three objects each, with specific properties (`firebase_id`, `member_id`, and `mobile_no`). The dataset is generated using the provided "Script Preparation Code".

**Pros and Cons of Each Approach:**

1. **Lodash _.map()**: This approach uses the `_.pick()` function from Lodash to extract specific properties from each object in the array. While convenient, this method may introduce overhead due to the library's dependencies and potential caching issues.
	* Pros: Simple, concise, and efficient (if properly optimized).
	* Cons: May rely on external libraries or have performance overhead.
2. **Traditional `for` loop**: This approach uses a manual `for` loop to iterate over the array elements and create a new object with extracted properties.
	* Pros: Lightweight, easy to understand, and can be highly optimized for specific use cases.
	* Cons: May require more code and maintenance effort compared to other approaches.
3. **Spread operator (`...`) with object destructuring**: This approach uses the spread operator to create a new object with extracted properties from each element in the array.
	* Pros: Modern, concise, and efficient (if properly used).
	* Cons: May require modern JavaScript versions or specific browser support.

**Library Usage**

The benchmark includes Lodash as a dependency. Lodash is a popular utility library for JavaScript that provides various helper functions, including `_.pick()`. Its purpose is to simplify common tasks and reduce code duplication by providing a set of pre-defined functions.

**Special JS Features or Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax beyond modern JavaScript versions (specifically, ECMAScript 2015+).

**Alternatives**

Other alternatives for transforming arrays in JavaScript include:

* Using `Array.prototype.map()` or `Array.prototype.forEach()` with a callback function.
* Utilizing `Array.prototype.reduce()` to accumulate objects.
* Leveraging `Array.prototype.filter()`, `Array.prototype.findIndex()`, and other array methods for filtering, searching, or manipulating data.

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

Related benchmarks:

_Mhai's Code (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):