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: 9 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];
}

​x
 
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));
tempSwap(new Array(10));
Length 10 destructuring swap
destructuringSwap(new Array(10));
destructuringSwap(new Array(10));
Length 100 temp swap
tempSwap(new Array(100));
tempSwap(new Array(100));
Length 100 destructuring swap
destructuringSwap(new Array(100));
destructuringSwap(new Array(100));
Length 1000 temp swap
tempSwap(new Array(1000));
tempSwap(new Array(1000));
Length 1000 destructuring swap
destructuringSwap(new Array(1000));
destructuringSwap(new Array(1000));
Length 10 xor swap
xorSwap(new Array(10));
xorSwap(new Array(10));
Length 100 xor swap
xorSwap(new Array(100));
xorSwap(new Array(100));
Length 1000 xor swap
xorSwap(new Array(1000));
xorSwap(new Array(1000));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: one month ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Linux

View result in a separate tab

Test name	Executions per second
Length 10 temp swap	33708244.0 Ops/sec
Length 10 destructuring swap	46224932.0 Ops/sec
Length 100 temp swap	17193668.0 Ops/sec
Length 100 destructuring swap	19618372.0 Ops/sec
Length 1000 temp swap	2885102.8 Ops/sec
Length 1000 destructuring swap	2962069.2 Ops/sec
Length 10 xor swap	32990530.0 Ops/sec
Length 100 xor swap	16357835.0 Ops/sec
Length 1000 xor swap	3115000.0 Ops/sec

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

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:

Temp variable swap: This approach uses a temporary variable to hold one of the swapped values.
Destructuring swap: This approach uses destructuring assignment to swap the values without using a temporary variable.
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:

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.
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.
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.

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: