Benchmark: String looping vs split

Script Preparation code:

var digits = Math.floor(Number.MAX_SAFE_INTEGER * Math.random()).toString() 
	+ Math.floor(Number.MAX_SAFE_INTEGER * Math.random()).toString();

Tests:

for loop
let sum = 0; for (let i = 0; i < digits.length; ++i) { sum += +digits[i]; }
Array.prototype.reduce.call
let sum = 0; sum = Array.prototype.reduce.call(digits, (prev, curr) => prev + +curr, 0);
Array.prototype.reduce.apply
let sum = 0; sum = Array.prototype.reduce.apply(digits, [(prev, curr) => prev + +curr, 0]);
Array.prototype.forEach
let sum = 0; Array.prototype.forEach.apply(digits, [(i) => sum += +i]);
.split.reduce
let sum = 0; sum = digits.split('').reduce((prev, curr) => prev + +curr, 0);
.split.forEach
let sum = 0; digits.split('').forEach((i) => sum += +i);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for loop
Array.prototype.reduce.call
Array.prototype.reduce.apply
Array.prototype.forEach
.split.reduce
.split.forEach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down what's being tested in this benchmark, explain the different approaches, and discuss their pros and cons.

**Benchmark Definition**

The benchmark is designed to compare the performance of six different methods for summing up the digits of a large random number string:

1. `for` loop
2. `Array.prototype.reduce.call`
3. `Array.prototype.reduce.apply`
4. `Array.prototype.forEach`
5. `.split.reduce`
6. `.split.forEach`

**Options compared**

Here's a brief overview of each option:

* **For loop**: A traditional iterative approach using a loop to iterate over the characters in the string and add them up.
* **`Array.prototype.reduce.call`**: A method invocation on the `Array` prototype that reduces the array of characters to a single value by applying a callback function. The first argument is the accumulator, and the second argument is the current character being processed.
* **`Array.prototype.reduce.apply`**: Similar to `reduce.call`, but uses the `apply` method to apply the callback function to an existing array object instead of creating a new one.
* **`Array.prototype.forEach`**: A method invocation on the `Array` prototype that iterates over the elements in the array and executes a callback function for each element.
* **`.split.reduce`**: An alternative implementation of `reduce` that splits the string into an array of characters using the `.split` method before applying the reduction logic. This approach avoids creating an intermediate array, which might be beneficial for large strings.
* **`.split.forEach`**: Similar to `.split.reduce`, but uses the `.forEach` method instead of `reduce`.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **For loop**: Simple and straightforward, but may not be as efficient due to the overhead of creating an empty string and incrementing the loop counter.
	+ Pros: Easy to understand and implement.
	+ Cons: May not be optimized for performance.
* **`Array.prototype.reduce.call`**: A concise and efficient approach that avoids creating intermediate arrays. However, it may require more setup and callback function definition.
	+ Pros: Efficient and concise.
	+ Cons: Requires more expertise in functional programming and method invocation.
* **`Array.prototype.reduce.apply`**: Similar to `reduce.call`, but uses the `apply` method instead of invoking the method directly. This approach can be beneficial for performance-critical code.
	+ Pros: Efficient and concise.
	+ Cons: May require more setup and callback function definition.
* **`Array.prototype.forEach`**: A simple and easy-to-understand approach that iterates over the array elements. However, it may not be as efficient due to the overhead of creating an intermediate array.
	+ Pros: Easy to understand and implement.
	+ Cons: May not be optimized for performance.
* **`.split.reduce`**: An alternative implementation of `reduce` that splits the string into an array of characters using the `.split` method. This approach avoids creating intermediate arrays, which might be beneficial for large strings.
	+ Pros: Efficient and concise.
	+ Cons: Requires understanding of the `.split` method and its limitations.
* **`.split.forEach`**: Similar to `.split.reduce`, but uses the `.forEach` method instead of `reduce`.
	+ Pros: Easy to understand and implement.
	+ Cons: May not be optimized for performance.

**Library usage**

There is no specific library being used in this benchmark. However, it's worth noting that some of these approaches rely on internal implementation details of JavaScript arrays or string manipulation methods.

**Special JS features or syntax**

None of the tested approaches use any special JavaScript features or syntax beyond standard array and string manipulation methods.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.80 Safari/537.36

Browser/OS: Chrome 86 on Mac OS X 10.15.5

View result in a separate tab

Test name	Executions per second
for loop	241296.7 Ops/sec
Array.prototype.reduce.call	400579.1 Ops/sec
Array.prototype.reduce.apply	391032.7 Ops/sec
Array.prototype.forEach	385475.3 Ops/sec
.split.reduce	2769820.0 Ops/sec
.split.forEach	2268313.5 Ops/sec

Related benchmarks:

String looping vs split (version: 0)

Comparing performance of: for loop vs Array.prototype.reduce.call vs Array.prototype.reduce.apply vs Array.prototype.forEach vs .split.reduce vs .split.forEach

Created: 4 years ago by: Registered User

Jump to the latest result

for loop

Array.prototype.reduce.call

Array.prototype.reduce.apply

Array.prototype.forEach

.split.reduce

.split.forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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