Benchmark: Reduce vs looping vs ifs

Script Preparation code:

var input = { foo: 'lorem', bar: 'ipsum', baz: null }
var reduce = (itemsArray, callback, seed) => {
  let accumulator = seed;
  for (let i = 0; i < itemsArray.length; i += 1) {
    accumulator = callback(accumulator, itemsArray[i], i);
  }
  return accumulator;
};

Tests:

Reduce
const keys = ['foo', 'bar', 'baz']; const setProperty = (acc, key, value) => value ? (acc[key] = value) && acc : acc; keys.reduce((acc, key) => setProperty(acc, key, input[key]), {});
Looping
const keys = ['foo', 'bar', 'baz']; const setProperty = (acc, key, value) => value ? (acc[key] = value) && acc : acc; reduce( keys, (acc, key) => setProperty(acc, key, input[key]), {} );
Ifs
const { foo, bar, baz } = input; const result = {}; if (foo) { result.foo = foo; } if (bar) { result.bar = bar; } if (baz) { result.baz = baz; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
Looping
Ifs

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmark, specifically testing three different approaches to merge an object with specific properties using the `input` object.

**Approaches Compared:**

1. **Reduce**: This approach uses the built-in `Array.prototype.reduce()` method to iterate over the keys of the `keys` array and update the accumulator (`acc`) with each key-value pair from the `input` object.
2. **Looping**: This approach uses a traditional loop (for...of) to iterate over the keys of the `keys` array and updates the accumulator (`acc`) with each key-value pair from the `input` object.
3. **Ifs**: This approach uses conditional statements (if-else) to check if a property exists in the `input` object for each key, and only adds it to the result object if present.

**Pros and Cons of Each Approach:**

* **Reduce**:
	+ Pros: More concise and efficient, as it leverages the optimized Array.prototype.reduce() method.
	+ Cons: May be less readable due to its conciseness, and may not perform well on smaller inputs.
* **Looping**:
	+ Pros: More explicit and easy to understand for beginners, and can handle larger inputs.
	+ Cons: Less efficient than Reduce due to the overhead of a traditional loop.
* **Ifs**:
	+ Pros: Easy to read and understand, especially for developers familiar with conditional statements.
	+ Cons: Less concise and may be slower due to the overhead of conditional checks.

**Library Used:**

None. This benchmark only uses built-in JavaScript functions and objects (e.g., Array.prototype.reduce(), for...of).

**Special JS Features/Syntax:**

* `Array.prototype.reduce()`: A method that applies a reduction function to each element in an array, accumulating a result.
* For-of loop: A new type of loop introduced in ECMAScript 2015, allowing iteration over arrays and other iterable objects.

**Other Considerations:**

* The benchmark only tests the performance of these three approaches on specific inputs (i.e., `input` object) and may not generalize to all possible use cases.
* The results might vary depending on the browser or environment used, as some optimizations or features might be present in certain implementations.

**Alternatives:**

Other approaches to merge objects with specific properties could include:

* Using a library like Lodash's `merge()` function
* Implementing a custom merge function using recursion or iteration
* Using a template string-based approach (e.g., `String.format()`)

Related benchmarks:

Reduce vs looping vs ifs (version: 0)

Comparing performance of: Reduce vs Looping vs Ifs

Created: 5 years ago by: Guest

Jump to the latest result

Reduce

Looping

Ifs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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