Benchmark: SteamRoler - MeasureThat.net

Script Preparation code:


function steamrollArraySimdi(arr) {
  // I'm a steamroller, baby
  var a = [];
  function roll(arr){
    
    if(!Array.isArray(arr)) {
      a.push(arr);
    }
    
  else {
    arr.forEach(x=>{
    roll(x);
    });
  }
  }
  
  roll(arr);
  return a;
}


var result = []

function steamrollArraySomeone(arr) {
  for(var i=0; i < arr.length; i++)
    Array.isArray(arr[i]) ? steamrollArraySomeone(arr[i]) : result.push(arr[i])
  return result;
}


function steamrollArrayConcat(arr) {

  for (var i = 0; i<=arr.length; i++){
  if (Array.isArray(arr[i]) === true){
    arr = arr.reduce( (a, b) => a.concat(b), []);
    i=0;
  }    
  }  

  return arr;
 
}

Tests:

steamrollArraySimdi
steamrollArraySimdi([[["a"]], [["b"]]]); steamrollArraySimdi([1, [2], [3, [[4]]]]); steamrollArraySimdi([1, {}, [3, [[4]]]]); steamrollArraySimdi([1, [], [3, [[4]]]]);
steamrollArraySomeone
steamrollArraySomeone([[["a"]], [["b"]]]); steamrollArraySomeone([1, [2], [3, [[4]]]]); steamrollArraySomeone([1, {}, [3, [[4]]]]); steamrollArraySomeone([1, [], [3, [[4]]]]);
steamrollArrayConcat
steamrollArrayConcat([[["a"]], [["b"]]]); steamrollArrayConcat([1, [2], [3, [[4]]]]); steamrollArrayConcat([1, {}, [3, [[4]]]]); steamrollArrayConcat([1, [], [3, [[4]]]]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
steamrollArraySimdi
steamrollArraySomeone
steamrollArrayConcat

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.

I'll break down the provided benchmark definition and test cases, explaining what's being tested, the options compared, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark is a JavaScript function that flattens an array of arrays into a single-level array. The benchmark provides three different implementations:

1. `steamrollArraySimdi(arr)`: This implementation uses recursion to flatten the array. It first checks if the input `arr` is not an array, in which case it pushes the value to an array `a`. If `arr` is an array, it calls a nested function `roll(arr)` that recursively flattens each element of the array.
2. `steamrollArraySomeone(arr)`: This implementation uses recursion as well, but with a different approach. It iterates over the input `arr`, and for each element, it checks if the element is an array using `Array.isArray(arr[i])`. If it is, it calls itself recursively with the same element, effectively flattening the nested array.
3. `steamrollArrayConcat(arr)`: This implementation uses a loop to flatten the array. It iterates over the input `arr` and checks if each element is an array using `Array.isArray(arr[i]) === true`. If it is, it concatenates all arrays in the input into a single array.

**Pros and Cons of Each Approach**

1. **steamrollArraySimdi**: This implementation uses recursion, which can lead to stack overflow errors for very deep nested arrays. However, it's concise and easy to understand.
	* Pros: Easy to implement, concise
	* Cons: Can lead to stack overflows, less efficient than other approaches
2. **steamrollArraySomeone**: This implementation also uses recursion but with a different approach. It's more complex than `steamrollArraySimdi` but can be more efficient for very deep nested arrays.
	* Pros: More efficient than `steamrollArraySimdi`, handles deep nested arrays better
	* Cons: More complex, harder to understand
3. **steamrollArrayConcat**: This implementation uses a loop and concatenation, which can lead to performance issues due to the overhead of creating new arrays.
	* Pros: Easy to implement, straightforward
	* Cons: Less efficient than other approaches, can lead to memory issues

**Other Considerations**

*   The benchmark uses a simple array of arrays as input, but in real-world scenarios, you might encounter more complex data structures or edge cases that need to be handled.
*   The `steamrollArraySomeone` implementation assumes that the input array is always an object with numeric keys, which can lead to unexpected behavior if the input format changes.

**Library and Special JS Features**

The benchmark uses no external libraries. However, it does use a feature called "arrow functions" (e.g., `arr.forEach(x=>{\r\nroll(x);\r\n})`) introduced in ECMAScript 2015. These arrow functions provide a concise way to define small, anonymous functions.

**Alternatives**

If you wanted to compare these benchmarks with different implementations, here are some alternatives:

*   **Iterative approach**: Implement `steamrollArraySimdi` using a loop instead of recursion.
*   **Using a library**: Use a JavaScript array flattening library like `flat()` or `flatten()`.
*   **Parallel execution**: Run each benchmark multiple times in parallel to see which one performs better for large inputs.
*   **Different browsers and devices**: Test the benchmarks on different browsers, operating systems, and devices to ensure they perform consistently across various environments.

Related benchmarks:

SteamRoler (version: 1)

Comparing performance of: steamrollArraySimdi vs steamrollArraySomeone vs steamrollArrayConcat

Created: 8 years ago by: Registered User

Jump to the latest result

steamrollArraySimdi

steamrollArraySomeone

steamrollArrayConcat

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