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;
    });
}

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
testArrayIteration
testArrayMap
testUnderscoreMap
testLodashMap

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.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that tests the performance of different methods for iterating over an array in JavaScript. Specifically, it compares four approaches:

1. **For loop**: A traditional `for` loop to iterate over each element in the array.
2. **Array.prototype.map()**: The built-in `map()` method to create a new array with the results of applying a provided function to each element in the original array.
3. **Lodash's `map()` function**: A utility function from the Lodash library that provides a more concise way to iterate over an array and transform its elements.
4. **Underscore.js's `map()` function**: Another utility function from the Underscore.js library that offers a similar functionality to Lodash's `map()`.

**Options compared**

The benchmark compares these four approaches in terms of their performance, specifically the number of executions per second (measured in "ExecutionsPerSecond").

**Pros and cons of each approach**

1. **For loop**:
	* Pros: Simple, well-understood syntax, no external dependencies.
	* Cons: Can be slow due to the overhead of the loop counter and conditional statements.
2. **Array.prototype.map()**:
	* Pros: Efficient use of JavaScript's built-in functions, easy to read and maintain.
	* Cons: May have slower performance than native loops due to function call overhead.
3. **Lodash's `map()` function**:
	* Pros: Provides a concise and expressive way to iterate over arrays, often with better performance than native `map()`.
	* Cons: Requires an external dependency (Lodash library), which may add latency.
4. **Underscore.js's `map()` function**:
	* Pros: Similar benefits to Lodash's `map()` as mentioned above.
	* Cons: Also requires an external dependency (Underscore.js library).

**Special JS feature or syntax**

None mentioned in the benchmark.

**Other considerations**

The benchmark is likely designed to provide insights into the performance characteristics of different JavaScript iteration methods. By comparing these approaches, developers can make informed decisions about which method to use depending on their specific use case and requirements.

If you're interested in running this benchmark yourself, you'll need to:

1. Create a new HTML file with the provided script preparation code.
2. Add the necessary scripts from Lodash and Underscore.js (as shown in the HTML Preparation Code).
3. Copy and paste the Individual test cases JSON into your browser's developer tools or a custom testing framework.

**Alternatives**

If you're looking for alternative benchmarking libraries, some popular options include:

1. **JSPerf**: A popular web-based benchmarking tool specifically designed for JavaScript performance comparisons.
2. **Benchmark.js**: Another well-known benchmarking library that provides features for measuring performance and comparing different implementations.
3. **V8's Benchmark Suite**: Google's V8 JavaScript engine provides a built-in benchmarking suite for testing various aspects of its performance.

These alternatives may offer more features, flexibility, or accuracy than MeasureThat.net, but they often require more setup and expertise to use effectively.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:41.0) Gecko/20100101 Firefox/41.0

Browser/OS: Firefox 41 on Mac OS X 10.11

View result in a separate tab

Test name	Executions per second
testArrayIteration	37725312.0 Ops/sec
testArrayMap	11395883.0 Ops/sec
testUnderscoreMap	12907391.0 Ops/sec
testLodashMap	14704527.0 Ops/sec

Related benchmarks:

Promo Map (version: 4)

Comparing performance of: testArrayIteration vs testArrayMap vs testUnderscoreMap vs testLodashMap

Created: 8 years ago by: Registered User

Jump to the latest result

testArrayIteration

testArrayMap

testUnderscoreMap

testLodashMap

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):