Benchmark: Ramda flatten function VS Array.prototype.flat

Script Preparation code:

function _isString(x) {
  return Object.prototype.toString.call(x) === '[object String]';
}

function _isPlaceholder(a) {
  return a != null &&
      typeof a === 'object' &&
      a['@@functional/placeholder'] === true;
}

function _curry1(fn) {
  return function f1(a) {
      if (arguments.length === 0 || _isPlaceholder(a)) {
          return f1;
      } else {
          return fn.apply(this, arguments);
      }
  };
}
var _isArrayLike = _curry1(function isArrayLike(x) {
  if (Array.isArray(x)) {
      return true;
  }
  if (!x) {
      return false;
  }
  if (typeof x !== 'object') {
      return false;
  }
  if (_isString(x)) {
      return false;
  }
  if (x.length === 0) {
      return true;
  }
  if (x.length > 0) {
      return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
  }
  return false;
});


function _makeFlat(recursive) {
  return function flatt(list) {
      var value, jlen, j;
      var result = [];
      var idx = 0;
      var ilen = list.length;

      while (idx < ilen) {
          if (_isArrayLike(list[idx])) {
              value = recursive ? flatt(list[idx]) : list[idx];
              j = 0;
              jlen = value.length;
              while (j < jlen) {
                  result[result.length] = value[j];
                  j += 1;
              }
          } else {
              result[result.length] = list[idx];
          }
          idx += 1;
      }
      return result;
    }
  };


  var flatten = _curry1(_makeFlat(true));

Tests:

Ramda Flatten Function
var params = [1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12], [1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11, [1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]], 12]]]]]]]; var other = flatten([1, 2, params]);
Array.prototype.flat
var params = [1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12], [1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11, [1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]], 12]]]]]]]; var other = [1, 2, params].flat(Infinity)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda Flatten Function
Array.prototype.flat

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:122.0) Gecko/20100101 Firefox/122.0

Browser/OS: Firefox 122 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Ramda Flatten Function	275295.2 Ops/sec
Array.prototype.flat	1116435.2 Ops/sec

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

LLMs can make mistakes. Check important info.

To analyze the provided benchmark, I'll break it down into sections and explain what's being tested.

**Benchmark Definition:**

The benchmark compares two approaches for flattening an array:

1. **Ramda Flatten Function**: The `flatten` function from Ramda, a functional programming library.
2. **Array.prototype.flat**: A built-in JavaScript method on the Array prototype.

**Options Compared:**

* Ramda's `flatten` function
* Array.prototype's `flat` method (with an optional second argument, which allows for more control over the flattening process)

**Pros and Cons of Each Approach:**

1. **Ramda Flatten Function:**
	* Pros:
		+ More flexible and customizable through currying and partial application.
		+ May be faster due to its implementation specifics ( Ramda is written in C++ for performance).
	* Cons:
		+ Requires including an external library, which may introduce dependencies and overhead.
		+ Less intuitive for developers without experience with functional programming.
2. **Array.prototype.flat:**
	* Pros:
		+ Built-in, so no additional library or dependency is required.
		+ Widely supported and understood by developers.
	* Cons:
		+ May be slower due to its implementation specifics (it's a JavaScript method, after all).
		+ Less flexible and customizable compared to Ramda's `flatten` function.

**Library:**

The benchmark uses the Ramda library. Ramda is a popular functional programming library for JavaScript that provides a set of higher-order functions for manipulating arrays and other data structures. The `flatten` function is one of its most useful utilities, allowing developers to easily flatten nested arrays.

**Special JS Feature or Syntax:**

There are no special JavaScript features or syntaxes being tested in this benchmark.

**Benchmark Preparation Code:**

The script preparation code includes several utility functions:

* `_isString`, `_isPlaceholder`, and `_curry1` are used to implement the Ramda `flatten` function.
* `_isArrayLike` is a helper function for determining whether an object is array-like.

These utility functions are necessary for the benchmark to work correctly, as they provide the implementation specifics for the Ramda `flatten` function and ensure that the test cases are properly formatted.

**Other Alternatives:**

If you don't want to use Ramda's `flatten` function or Array.prototype's `flat` method, there are alternative ways to flatten an array in JavaScript:

1. **Manual iteration**: You can write a simple loop to iterate over each element of the nested array and append it to a new array.
2. **Using `reduce()`**: You can use the `reduce()` method to accumulate elements from a nested array into a single array.
3. **Using a library like Lodash**: Lodash is another popular utility library for JavaScript that provides an implementation of the `flatten` function.

Keep in mind that these alternatives may have their own trade-offs and performance characteristics, so it's essential to choose the right approach depending on your specific use case.

Related benchmarks:

Ramda flatten function VS Array.prototype.flat (version: 0)

Compare a Ramda flatten function with Array.prototype.flat

Comparing performance of: Ramda Flatten Function vs Array.prototype.flat

Created: 3 years ago by: Guest

Jump to the latest result

Ramda Flatten Function

Array.prototype.flat

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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