Benchmark: Promo Map - MeasureThat.net

HTML Preparation code:

<html>
    <head>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>
        <script>
        underscore = _;
        </script>


        <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.12.0/lodash.min.js"></script>

        <script>
        lodash = _;
        </script>
    </head>
    <body>
    </body>
</html>

Script Preparation code:


var PromosArray = [
    {
        type: "regular",
        display: "$123.00"
    },
    {
        type: "markdown",
        display: "$100.00"
    },
    {
        type: "promo",
        display: "$80.00"
    }
];

function testArrayIteration() {
    var items = [];
    var i;

    for (i = 0; i < PromosArray.length; i++) {
        items.push(PromosArray[i].type);
    }

    return items;
  
}

function testArrayMap() {
    return PromosArray.map(function (promo) {
        return promo.type;
    });
}

function testUnderscoreMap() {
    return underscore.map(PromosArray, function (promo) {
        return promo.type;
    });
}

function testLodashMap() {
    return lodash.map(PromosArray, function (promo) {
        return promo.type;
    });
}

function testForLoop() {
    var items = [];
  
  	for (var i = 0; i < PromosArray.length; i++) {
     	items.push(PromosArray[i].type); 
    }
  
  	return items;
}

Tests:

testArrayIteration
testArrayIteration();
testArrayMap
testArrayMap();
testUnderscoreMap
testUnderscoreMap();
testLodashMap
testLodashMap();
testForLoop
testForLoop();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
testArrayIteration
testArrayMap
testUnderscoreMap
testLodashMap
testForLoop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark measures the performance of four different approaches to iterate over an array of objects:

1. **For Loop**: A traditional for loop using a variable `i` to iterate over the array.
2. **Array Map**: Using the `map()` method on the array to create a new array with the same number of elements, but with each element being a transformed version of the original one.
3. **Underscore Map**: Using the `map()` function from the Underscore.js library to perform the transformation.
4. **Lodash Map**: Using the `map()` function from the Lodash.js library to perform the transformation.

**Comparison of Approaches**

Here's a brief summary of each approach:

*   For Loop: This is a traditional, imperative approach that uses a variable `i` to iterate over the array and push each element into a new array.
*   Array Map: This is a declarative approach that uses the `map()` method on the array to create a new array with the same number of elements. The function passed to `map()` is called for each element in the original array, and its return value is used as the corresponding element in the new array.
*   Underscore Map: This is similar to the Array Map approach, but uses the `map()` function from the Underscore.js library to perform the transformation. The Underscore.js library provides a set of functional programming helpers that can be used to simplify common tasks, such as map transformations.
*   Lodash Map: This is similar to the Underscore Map approach, but uses the `map()` function from the Lodash.js library to perform the transformation.

**Pros and Cons of Each Approach**

Here are some pros and cons for each approach:

*   For Loop:
    *   Pros:
        *   Easy to understand and implement.
        *   Can be optimized for performance using techniques like caching or parallelization.
    *   Cons:
        *   Can be slow due to the overhead of incrementing a variable and checking bounds.
        *   Limited scalability as the loop size increases.
*   Array Map:
    *   Pros:
        *   Easy to understand and implement.
        *   Scalable, as the function passed to `map()` can handle any number of elements.
    *   Cons:
        *   Can be slower than other approaches due to the overhead of creating a new array.
        *   May not be suitable for large datasets that don't fit into memory.
*   Underscore Map and Lodash Map:
    *   Pros:
        *   Simplify common tasks, making code more concise and readable.
        *   Often provide built-in optimizations or caching to improve performance.
    *   Cons:
        *   May have additional overhead due to the presence of a library.
        *   Can introduce complexity if not used carefully.

**Library Considerations**

The benchmark uses two libraries:

*   Underscore.js: A utility-first JavaScript library that provides a set of functional programming helpers, including `map()`.
*   Lodash.js: A high-performance version of the Underscore.js library that provides additional optimization and caching to improve performance.

Both libraries are designed to simplify common tasks and provide a concise way to write code. However, they also introduce additional overhead due to the presence of a library.

**Conclusion**

In conclusion, the benchmark measures the performance of four different approaches to iterate over an array of objects: For Loop, Array Map, Underscore Map, and Lodash Map. Each approach has its pros and cons, and the choice of which one to use depends on the specific requirements and constraints of the project.

It's worth noting that the performance differences between these approaches can be significant, especially for large datasets or performance-critical code paths.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36

Browser/OS: Chrome 52 on Windows

View result in a separate tab

Test name	Executions per second
testArrayIteration	1225445.9 Ops/sec
testArrayMap	1573433.6 Ops/sec
testUnderscoreMap	2036193.0 Ops/sec
testLodashMap	2099738.0 Ops/sec
testForLoop	1229341.1 Ops/sec

Related benchmarks:

Promo Map (version: 0)

Comparing performance of: testArrayIteration vs testArrayMap vs testUnderscoreMap vs testLodashMap vs testForLoop

Created: 8 years ago by: Registered User

Jump to the latest result

testArrayIteration

testArrayMap

testUnderscoreMap

testLodashMap

testForLoop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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