Benchmark: reduce_foreach - MeasureThat.net

Script Preparation code:

function generateInsertStatement1(data) {
    let values = [];
    Object.keys(data).forEach(subjectId => {
        data[subjectId].forEach((questionId, index) => {
            values.push(`(${index + 1},${subjectId},${questionId})`);
        });
    });
    return `INSERT INTO question (sequence,subjectid,questionId) VALUES ${values.join(',')};`;
}
function generateInsertStatement2(data) {
    const values = Object.entries(data).reduce((acc, [subjectId, questionIds]) => {
        const subjectValues = questionIds.map((questionId, index) => `(${index + 1},${subjectId},${questionId})`);
        return acc.concat(subjectValues);
    }, []);
    return `INSERT INTO question (sequence,subjectid,questionId) VALUES ${values.join(',')};`;
}

Tests:

reduce
const questionsData = { "4": [4796, 4590], "5": [1141, 947, 1451, 1343, 943, 1088, 2990, 2971, 1504, 3104] }; const sqlStatement2 = generateInsertStatement2(questionsData);
foreach
const questionsData = { "4": [4796, 4590], "5": [1141, 947, 1451, 1343, 943, 1088, 2990, 2971, 1504, 3104] }; const sqlStatement1 = generateInsertStatement1(questionsData);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
foreach

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Linux; Android 10; SAMSUNG SM-J810G) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/16.0 Chrome/92.0.4515.166 Mobile Safari/537.36

Browser/OS: Chrome Mobile 92 on Android

View result in a separate tab

Test name	Executions per second
reduce	26571.2 Ops/sec
foreach	31323.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Definition**

The benchmark measures the performance difference between two approaches to generate an SQL insert statement: `foreach` and `reduce`.

**Options Compared**

There are two options compared:

1. **`foreach`**: This approach uses a traditional `forEach` loop to iterate over the data object. It's a simple and straightforward way to access each element of the array.
2. **`reduce`**: This approach uses the `Array.prototype.reduce()` method to accumulate the values into an array, which is then used to generate the SQL insert statement.

**Pros and Cons**

* **`foreach`**:
	+ Pros: Easy to understand, straightforward implementation.
	+ Cons: May be slower due to the overhead of looping over the array.
* **`reduce`**:
	+ Pros: Can be faster since it avoids the overhead of looping over the array, and is often used in performance-critical code paths.
	+ Cons: Requires a good understanding of the `reduce()` method and its implementation details.

**Library/Functionality Used**

The benchmark uses two functions:

1. **`generateInsertStatement1(data)`**: This function uses a traditional `forEach` loop to generate the SQL insert statement.
2. **`generateInsertStatement2(data)`**: This function uses the `Array.prototype.reduce()` method to accumulate the values into an array.

Both functions are part of the benchmark, but they're not external libraries. They're implemented as part of the test case.

**Special JS Feature/Syntax**

There's no special JavaScript feature or syntax used in this benchmark. It only relies on standard ES6+ features and common practices.

**Other Considerations**

When choosing between these two approaches, consider the trade-offs:

* If readability and maintainability are more important than performance, use the `foreach` approach.
* If performance is critical, use the `reduce` approach (but make sure you understand its implementation details).

As for alternatives, there are other ways to generate SQL insert statements, such as using template literals or string formatting functions. However, these approaches may not be as efficient or scalable as the `reduce()` method.

Keep in mind that this benchmark is focused on measuring the performance difference between two specific approaches. If you're looking for more comprehensive benchmarking, consider running it on your own JavaScript runtime with different input data and configurations.

Related benchmarks:

reduce_foreach (version: 0)

Comparing performance of: reduce vs foreach

Created: one year ago by: Guest

Jump to the latest result

reduce

foreach

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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