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: 2 years ago by: Registered User

Go 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: 9 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

Length 10 destructuring swap

52.7M/s

Length 10 xor swap

41.8M/s

Length 10 temp swap

40.1M/s

Length 100 destructuring swap

22.4M/s

Length 100 temp swap

21.5M/s

Length 100 xor swap

20.7M/s

Length 1000 destructuring swap

3.5M/s

Length 1000 temp swap

3.4M/s

Length 1000 xor swap

3.0M/s

View exact numbers

Test name	Executions per second
✓ Length 10 destructuring swap	52,704,984 Ops/sec
Length 10 xor swap	41,836,324 Ops/sec
Length 10 temp swap	40,125,360 Ops/sec
Length 100 destructuring swap	22,354,640 Ops/sec
Length 100 temp swap	21,458,682 Ops/sec
Length 100 xor swap	20,714,988 Ops/sec
Length 1000 destructuring swap	3,454,685 Ops/sec
Length 1000 temp swap	3,367,782 Ops/sec
Length 1000 xor swap	2,993,624 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.