Benchmark: Shuffle Array - MeasureThat.net

Script Preparation code:

function suffle(arr) {
    const len = arr.length;
    for (let i = len - 1; i >= 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [arr[i], arr[j]] = [arr[j], arr[i]];
    }
    return arr;
}


var obj = [];
for (let i = 0; i < 100; i++) {
    obj.push({
        [i]: i,
        [i + 1]: i + 1,
        [i + 2]: i + 2,
        [i + 3]: i + 3
    });
}


var num = [];
for (let i = 0; i < 100; i++) {
    num.push(i);
}

Tests:

Large Object Contents
suffle(obj);
Number Content
suffle(num);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Large Object Contents
Number Content

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
Large Object Contents	36802.2 Ops/sec
Number Content	36799.9 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 and benchmark preparation code to understand what is being tested on MeasureThat.net.

**Benchmark Definition JSON**

The benchmark definition represents a JavaScript function that shuffles an array of objects with multiple properties. The function, `suffle`, takes an array as input, iterates through it in reverse order, and swaps each element with a randomly selected element from the remaining unswapped portion of the array.

**Script Preparation Code**

The script preparation code is a JavaScript function that creates two arrays: `obj` and `num`. The `obj` array contains 100 objects with four properties each ( `[i]`, `[i+1]`, `[i+2]`, and `[i+3]`) where the property values are equal to the index `i`. The `num` array contains 100 integers from 0 to 99.

**Html Preparation Code**

The html preparation code is currently empty, which means that no HTML is generated or modified before running the benchmark.

**Individual Test Cases**

There are two test cases:

1. **Large Object Contents**: This test case runs the `suffle` function on the `obj` array.
2. **Number Content**: This test case runs the `suffle` function on the `num` array.

**Options Compared**

The benchmark compares the performance of shuffling arrays with different properties (object vs. integer).

**Pros and Cons of Each Approach**

1. **Shuffling objects**: Pros:
	* Can be more efficient than shuffling integers, as objects may have fewer collisions.
	* May produce a more uniform distribution of elements in the shuffled array.
2. **Shuffling integers**: Pros:
	* Typically faster and more lightweight than shuffling objects.
	* Produces a predictable and consistent distribution of elements in the shuffled array.

Cons:

1. **Object shuffling**:
	* May be slower due to object creation and property access.
	* Can lead to collisions if multiple properties have the same value.
2. **Integer shuffling**:
	* May require additional memory for the integer values.
	* Can result in a less uniform distribution of elements in the shuffled array.

**Library Used**

There is no explicit library used in this benchmark. The `suffle` function uses only built-in JavaScript features and data structures (arrays and objects).

**Special JS Feature or Syntax**

This benchmark does not use any special JavaScript features or syntax that would impact performance. However, it's worth noting that the use of arrays and object properties can affect performance depending on the browser implementation.

**Other Considerations**

When shuffling arrays, consider the following factors:

1. **Collision probability**: The likelihood of two elements having the same value or property.
2. **Distribution uniformity**: How evenly the shuffled array is distributed, which can impact performance and randomness requirements.
3. **Memory usage**: The amount of memory required to store the shuffled array, especially for large inputs.

Alternatives to MeasureThat.net:

1. **Benchmarking libraries**: Such as Benchmark.js or Microbenchmark.
2. **Browser-specific benchmarking tools**: Like Chrome DevTools' Performance tab or Firefox's Performance tab.
3. **Open-source benchmarking frameworks**: Like JMeter or Gatling.

Note: These alternatives may offer more features, flexibility, and customization options than MeasureThat.net.

Related benchmarks:

Shuffle Array (version: 0)

Comparing performance of: Large Object Contents vs Number Content

Created: 3 years ago by: Guest

Jump to the latest result

Large Object Contents

Number Content

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