Benchmark: Every Third Element

Script Preparation code:

var fruits = ["Banana", "yellow", "23", "Orange", "orange", "12", "Apple", "green", "10"];

Tests:

Push to new array
var firstFruits = []; for (var i = 0; i < fruits.length; i = i+3) { firstFruits.push(fruits[i]); };
Splice
for(var i = 0; i < fruits.length; i++) { fruits.splice(i+1,2); }
Filter
var filtered = fruits.filter(function(_, i) { return (i % 3 == 0); })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Push to new array
Splice
Filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 67 on Mac OS X 10.14

View result in a separate tab

Test name	Executions per second
Push to new array	21465130.0 Ops/sec
Splice	13790847.0 Ops/sec
Filter	34620820.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the JavaScript microbenchmark on MeasureThat.net.

**Benchmark Definition**

The benchmark is defined by providing a script preparation code and an HTML preparation code (which is empty in this case). The script preparation code defines an array of fruit names with some numbers embedded, representing the test data. The HTML preparation code is not used in this benchmark.

**Test Cases**

There are three individual test cases:

1. **Push to new array**: This test creates a new empty array `firstFruits` and then pushes every third element from the original `fruits` array into it.
2. **Splice**: This test removes two elements starting from the index `i+1` from the original `fruits` array.
3. **Filter**: This test filters the original `fruits` array to only include elements whose index is a multiple of 3.

**Options Compared**

The three test cases compare different approaches for manipulating arrays:

*   Using `push()` with creating a new array (`Push to new array`)
*   Using `splice()` without modifying the original array (`Splice`)
*   Using `filter()` with filtering out elements based on their index (`Filter`)

**Pros and Cons of Each Approach**

1.  **Push to new array**
    *   **Pros:** Easy to understand, efficient in terms of performance since it doesn't modify the original array.
    *   **Cons:** Creates a new array, which can lead to memory allocation issues if not managed correctly.

2.  **Splice**
    *   **Pros:** Modifies the original array without creating a new one, thus potentially more memory-efficient compared to `push()`.
    *   **Cons:** More complex and less intuitive than using `push()` or `filter()`, may have performance issues if not used carefully.

3.  **Filter**
    *   **Pros:** Does not modify the original array, easy to read and maintain.
    *   **Cons:** May be slower than `splice()` since it involves creating a new filtered array, which can lead to more memory allocation.

**Libraries Used**

None are explicitly mentioned in this benchmark. However, JavaScript's built-in methods like `Array.prototype.push()`, `Array.prototype.splice()`, and `Array.prototype.filter()` are used.

**Special JS Feature or Syntax**

The use of the arrow function (`function(_, i) { return (i % 3 == 0); }`) is a special feature. It provides a concise way to define small anonymous functions without declaring them as full-fledged functions using the `function` keyword.

**Alternatives**

If you were to rewrite these benchmarks, consider the following alternatives:

*   Instead of creating a new array on each push operation (`push()`), consider using `slice()` or other methods to extract elements from the original array.
*   When removing elements with `splice()`, consider handling edge cases like when the start index is out of range or when there are not enough elements left in the array.
*   For filtering, consider using more efficient algorithms like `map()` or `every()` instead of `filter()` if performance is critical.

Keep in mind that these alternatives would depend on your specific requirements and constraints. The original approach provides a straightforward way to demonstrate each method's behavior.

Related benchmarks:

Every Third Element (version: 0)

Comparing performance of: Push to new array vs Splice vs Filter

Created: 8 years ago by: Guest

Jump to the latest result

Push to new array

Splice

Filter

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