Benchmark: Array item swapping, destructuring vs temp variable vs xor

Array item swapping, destructuring vs temp variable vs xor (version: 1)

Array destructuring vs temp variable use in array item swapping

Comparing performance of: Length 10 temp swap vs Length 10 destructuring swap vs Length 100 temp swap vs Length 100 destructuring swap vs Length 1000 temp swap vs Length 1000 destructuring swap vs Length 10 xor swap vs Length 100 xor swap vs Length 1000 xor swap

Created: 3 months ago by: Registered User

Jump to the latest result

Script Preparation code:

function tempSwap(array) {
    const length = array.length;
    const swap1 = Math.floor(Math.random() * length);
    const swap2 = Math.floor(Math.random() * length);
    const temp = array[swap1];

    array[swap1] = array[swap2];
    array[swap2] = array[temp];
}

function destructuringSwap(array) {
    const length = array.length;
    const swap1 = Math.floor(Math.random() * length);
    const swap2 = Math.floor(Math.random() * length);

    return [
        array[swap1],
        array[swap2]
    ] = [
        array[swap2],
        array[swap1]
    ];
}

function xorSwap(array) {
const length = array.length;
    const swap1 = Math.floor(Math.random() * length);
    const swap2 = Math.floor(Math.random() * length);
    array[swap1] ^= array[swap2];
    array[swap2] ^= array[swap1];
    array[swap1] ^= array[swap2];
}

Tests:

Length 10 temp swap
tempSwap(new Array(10));
Length 10 destructuring swap
destructuringSwap(new Array(10));
Length 100 temp swap
tempSwap(new Array(100));
Length 100 destructuring swap
destructuringSwap(new Array(100));
Length 1000 temp swap
tempSwap(new Array(1000));
Length 1000 destructuring swap
destructuringSwap(new Array(1000));
Length 10 xor swap
xorSwap(new Array(10));
Length 100 xor swap
xorSwap(new Array(100));
Length 1000 xor swap
xorSwap(new Array(1000));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Length 10 temp swap
Length 10 destructuring swap
Length 100 temp swap
Length 100 destructuring swap
Length 1000 temp swap
Length 1000 destructuring swap
Length 10 xor swap
Length 100 xor swap
Length 1000 xor swap

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to array item swapping in JavaScript can be a complex task.

**What is being tested?**

The provided benchmark test case compares three approaches to swapping two elements in an array:

1. **Temp variable swap**: This approach uses a temporary variable to hold one of the swapped values.
2. **Destructuring swap**: This approach uses destructuring assignment to swap the values without using a temporary variable.
3. **XOR swap**: This approach uses bitwise XOR operation to swap the values.

**Options being compared:**

The benchmark test case compares the execution speed of these three approaches for different array sizes (10, 100, and 1000).

**Pros and cons of each approach:**

1. **Temp variable swap**:
	* Pros: Easy to understand and implement, works well for small arrays.
	* Cons: Requires a temporary variable, which can lead to unnecessary memory allocation and deallocation.
2. **Destructuring swap**:
	* Pros: Efficient use of memory, eliminates the need for a temporary variable.
	* Cons: May be less intuitive to understand and implement, especially for developers without experience with destructuring assignment.
3. **XOR swap**:
	* Pros: Uses bitwise operations, which can be faster than arithmetic operations, and eliminates the need for a temporary variable.
	* Cons: Requires understanding of bitwise XOR operation, which may not be familiar to all developers.

**Other considerations:**

* The benchmark results are specific to Firefox 128 on Windows desktop, so the performance may vary on other browsers or platforms.
* The test cases use arrays with random lengths and values, which can affect the performance. More realistic test cases might use fixed-size arrays or arrays with specific patterns of values.

Overall, the benchmark highlights the importance of considering different approaches to array item swapping in JavaScript, especially when working with large datasets or performance-critical code.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0

Browser/OS: Firefox 128 on Windows

View result in a separate tab

Test name	Executions per second
Length 10 temp swap	16143024.0 Ops/sec
Length 10 destructuring swap	14185961.0 Ops/sec
Length 100 temp swap	8796710.0 Ops/sec
Length 100 destructuring swap	3342906.0 Ops/sec
Length 1000 temp swap	550042.6 Ops/sec
Length 1000 destructuring swap	557293.6 Ops/sec
Length 10 xor swap	15054834.0 Ops/sec
Length 100 xor swap	8785480.0 Ops/sec
Length 1000 xor swap	547070.6 Ops/sec

Related benchmarks:

Array item swapping, destructuring vs temp variable vs xor (version: 1)

Array destructuring vs temp variable use in array item swapping

Comparing performance of: Length 10 temp swap vs Length 10 destructuring swap vs Length 100 temp swap vs Length 100 destructuring swap vs Length 1000 temp swap vs Length 1000 destructuring swap vs Length 10 xor swap vs Length 100 xor swap vs Length 1000 xor swap

Created: 3 months ago by: Registered User

Jump to the latest result

Length 10 temp swap

Length 10 destructuring swap

Length 100 temp swap

Length 100 destructuring swap

Length 1000 temp swap

Length 1000 destructuring swap

Length 10 xor swap

Length 100 xor swap

Length 1000 xor swap

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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