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: one year 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

Latest run results:

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

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

Browser/OS: Chrome 142 on Windows

View result in a separate tab

Test name	Executions per second
Length 10 temp swap	40125360.0 Ops/sec
Length 10 destructuring swap	52704984.0 Ops/sec
Length 100 temp swap	21458682.0 Ops/sec
Length 100 destructuring swap	22354640.0 Ops/sec
Length 1000 temp swap	3367782.0 Ops/sec
Length 1000 destructuring swap	3454685.0 Ops/sec
Length 10 xor swap	41836324.0 Ops/sec
Length 100 xor swap	20714988.0 Ops/sec
Length 1000 xor swap	2993624.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

Related benchmarks: