Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Reduce vs map/join with existing strings on an object
(version: 0)
Comparing performance of:
for vs reduce vs map vs for of
Created:
3 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var strings = []; for (var i=0; i<1000; i++) { strings[i] = { name: 'test' + i }; }
Tests:
for
var result = ""; for (var i=0; i<strings.length; i++) { result = result+';;'+strings[i].name; } result=result.substring(2);
reduce
var result = strings.reduce(function(string, i) { return string+';;'+i.name; }, ""); result=result.substring(2);
map
var result = strings.map(function(i) { return i.name; }).join(';;');
for of
var result = ""; for (var i of strings) { result += ';;' + i; }
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (4)
Previous results
Fork
Test case name
Result
for
reduce
map
for of
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 months ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0
Browser/OS:
Firefox 151 on Mac OS X 10.15
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=629249" width="100%" height="500px"></iframe>
reduce
105K/s
map
94K/s
for
45K/s
for of
10K/s
View exact numbers
Test name
Executions per second
✓
reduce
104,739 Ops/sec
map
94,104 Ops/sec
for
44,641 Ops/sec
for of
10,350 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's dive into the explanation of the provided JSON benchmark definition and test cases. **Benchmark Definition Overview** The benchmark measures the performance of three different approaches to concatenate strings: `for`, `map/join with existing strings on an object`, and `for of`. The benchmark uses a JavaScript array of objects, where each object has a `name` property. The goal is to concatenate all the `name` properties of these objects into a single string. **Options Compared** The three options compared are: 1. **For loop**: This approach uses a traditional `for` loop to iterate over the array and concatenate the strings. 2. **Array.prototype.reduce()**: This method applies a reduction function to each element in the array, concatenating the results into a single string. 3. **Array.prototype.map()** + **String.prototype.join()**: This approach maps the array to an array of strings using `map()` and then joins these strings together with `join()`. **Pros and Cons** Here's a brief summary of each approach: 1. **For loop**: * Pros: Simple, easy to understand, and often used in everyday JavaScript code. * Cons: Can be slower than other approaches due to the overhead of the `for` loop. 2. **Array.prototype.reduce()**: * Pros: Efficient for concatenating large arrays, as it avoids creating intermediate strings. * Cons: May have a higher memory footprint due to the use of an accumulator function. 3. **Array.prototype.map()** + **String.prototype.join()**: * Pros: Often faster than `for` loop or `reduce()` due to the optimized performance of `map()` and `join()`. * Cons: Creates intermediate arrays, which can increase memory usage. **Library/Functionality Used** None of the approaches rely on external libraries. However, all three use built-in JavaScript functions: 1. **For loop**: Uses the `for` loop and string concatenation (`+` operator). 2. **Array.prototype.reduce()**: Uses the `reduce()` method and a callback function. 3. **Array.prototype.map()** + **String.prototype.join()**: Uses the `map()` method, which creates an intermediate array, and then uses the `join()` method to concatenate the strings. **Special JS Feature/Syntax** None of the approaches use special JavaScript features or syntax beyond what's shown in the benchmark definition. However, it's worth noting that the `for...of` loop (used in the third option) is a relatively new feature introduced in ECMAScript 2015 (ES6). **Other Alternatives** If you're looking for alternative approaches to concatenate strings in JavaScript, some other options include: 1. **String.prototype.concat()**: While not as efficient as `map()` + `join()`, this method can be used to concatenate strings in a loop. 2. **Array.prototype.slice().concat()**: This approach creates an intermediate array and concatenates the strings using `concat()`. 3. **Template literals**: A relatively new feature introduced in ECMAScript 2015 (ES6), template literals allow you to create strings with embedded expressions. Keep in mind that these alternatives may have different performance characteristics depending on your specific use case.
Related benchmarks
Reduce vs map/join
Array<string>.join vs Array<string>.reduce
map and join vs reduce
map and join vs reduce small array
Comments
Confirm delete:
Do you really want to delete benchmark?