使用js写个方法，使得数组的两个元素互换，要求高性能

/**
 * Swaps two elements in an array in-place with high performance.
 * Uses destructuring assignment for optimal speed.
 *
 * @param {Array} arr The array to modify.
 * @param {number} index1 The index of the first element to swap.
 * @param {number} index2 The index of the second element to swap.
 */
function swap(arr, index1, index2) {
  [arr[index1], arr[index2]] = [arr[index2], arr[index1]];
}


// Example usage and performance test:
const arr = [1, 2, 3, 4, 5];

console.log("Original array:", arr);
swap(arr, 1, 3);
console.log("Array after swapping elements at indices 1 and 3:", arr);


// Performance test (optional - uncomment to run):
/*
const largeArray = Array.from({ length: 100000 }, (_, i) => i);

console.time("Swap performance");
for (let i = 0; i < 10000; i++) {
  swap(largeArray, i % largeArray.length, (i + 100) % largeArray.length);
}
console.timeEnd("Swap performance");
*/



//Alternative using a temporary variable (slightly less performant but more widely compatible with older JS engines):

function swapTemp(arr, index1, index2) {
  const temp = arr[index1];
  arr[index1] = arr[index2];
  arr[index2] = temp;
}

Explanation and Performance Considerations:

• Destructuring Assignment: The primary method, swap(arr, index1, index2), uses destructuring assignment ([arr[index1], arr[index2]] = [arr[index2], arr[index1]];). This is generally the most performant way to swap array elements in modern JavaScript engines as it's often optimized to a single operation.

• Temporary Variable (Alternative): The swapTemp function provides an alternative using a temporary variable. This is slightly less performant than destructuring but is more compatible with older JavaScript environments that might not support destructuring.

• In-Place Modification: Both methods modify the original array directly (in-place) rather than creating a new array. This is more memory-efficient, especially for large arrays.

• Error Handling (Optional): For production code, you might want to add checks to ensure that index1 and index2 are within the valid bounds of the array to prevent errors. For example:

function swapSafe(arr, index1, index2) {
  if (index1 < 0 || index1 >= arr.length || index2 < 0 || index2 >= arr.length) {
    return; // Or throw an error
  }
  [arr[index1], arr[index2]] = [arr[index2], arr[index1]];
}

• Performance Test: The commented-out performance test code provides a way to benchmark the swap function on a large array. You can uncomment it to see the execution time in your environment. Remember that performance can vary depending on the JavaScript engine and other factors.

By using destructuring assignment and modifying the array in-place, this swap function offers a highly performant way to exchange elements within a JavaScript array. Choose the method that best suits your compatibility and coding style needs.