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

​x
 
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]);

 
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)

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year 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 7 months ago):

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:

Ramda Flatten Function: The flatten function from Ramda, a functional programming library.
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:

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

Manual iteration: You can write a simple loop to iterate over each element of the nested array and append it to a new array.
Using reduce(): You can use the reduce() method to accumulate elements from a nested array into a single array.
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.

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: 2 years ago by: Guest

Jump to the latest result