Benchmark: array slice vs immutable-js takeLast

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.2/immutable.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/immutability-helper@2.7.0/index.min.js"></script>

Tests:

array slice
const data = new Array(300).fill(55); let initArr = new Array(10000).fill(88); const limitArr = (arr, limit) => (arr.length > limit ? arr.slice(-limit) : arr); for(i=0; i<100; i++) { initArr.push(...data); initArr = limitArr(initArr, 1000); }
immutable-js
const data = new Array(300).fill(55); let initList = Immutable.List(); initList = initList.push(...(new Array(10000).fill(88))); const limitList = (list, limit) => (list.size > limit ? list.takeLast(limit) : list); for(i=0; i<100; i++) { initList = limitList(initList.push(...data), 1000); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array slice
immutable-js

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36

Browser/OS: Chrome 103 on Windows

View result in a separate tab

Test name	Executions per second
array slice	7354.7 Ops/sec
immutable-js	97.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark definition and test cases.

**Benchmark Definition:**

The script preparation code is empty, which means that the JavaScript interpreter will execute the provided benchmark definitions from scratch for each execution.

The HTML preparation code includes two external libraries:

1. **Immutable.js**: a library for working with immutable data structures.
2. **Immutability-helper**: a utility library for Immutable.js.

**Test Cases:**

There are two test cases:

### Array Slice Test Case

The benchmark definition is:
```javascript
const data = new Array(300).fill(55);
let initArr = new Array(10000).fill(88);
const limitArr = (arr, limit) => (arr.length > limit ? arr.slice(-limit) : arr);

for(i=0; i<100; i++) {
  initArr.push(...data);
  initArr = limitArr(initArr, 1000);
}
```
This test case creates a large array `initArr` and pushes a smaller array `data` into it repeatedly. The `limitArr` function is used to slice the resulting array down to a specified length.

**What's being tested:**

The main operation being tested here is the use of the `slice()` method on an array, which creates a new array containing a subset of elements from the original array.

**Options compared:**

In this case, there are only two options being compared:

1. **Array slicing**: using the `slice()` method to truncate the array.
2. **Immutable.js takeLast**: using the `takeLast()` function from Immutable.js to get the last N elements of an immutable list.

**Pros and Cons:**

* **Array Slicing**:
	+ Pros: efficient, widely supported, easy to understand.
	+ Cons: can create a new array object, which may lead to memory allocation issues for large arrays.
* **Immutable.js takeLast**:
	+ Pros: creates an immutable data structure, reducing side effects and making the code more predictable.
	+ Cons: requires additional library dependencies (Immutable.js), can be slower due to immutability overhead.

**Other Considerations:**

The use of `slice()` on large arrays may lead to performance issues due to the creation of a new array object. In contrast, Immutable.js' `takeLast()` function creates an immutable list and only updates the underlying data structure when necessary, which can be more efficient in the long run.

**Immutability-helper library:**

In this case, the Immutability-helper library is used to simplify the usage of Immutable.js's `takeLast()` function. The library provides a more concise API for working with immutable lists.

If test users special JS feature or syntax:

There are no special features or syntaxes being tested in these benchmark cases. If such features were present, they would be relevant to the discussion.

**Other Alternatives:**

Alternative approaches to array slicing include using `Array.prototype.slice.call()` or a library like Lodash's `_.slice()`. However, these approaches may not offer significant performance improvements over native `slice()`.

For immutable data structures, other libraries such as Ramda or xs are also available. These libraries provide more comprehensive support for functional programming and immutability, but require additional dependencies and learning curves.

Related benchmarks:

array slice vs immutable-js takeLast (version: 0)

Comparing performance of: array slice vs immutable-js

Created: 4 years ago by: Guest

Jump to the latest result

array slice

immutable-js

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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