使用解构赋值交换 `a[i]` 和 `a[a[i]]` 时失败，根本原因在于右侧表达式先求值、左侧赋值按顺序执行，而动态索引（如 `a[a[0]]`）在赋值过程中因左操作数已变更导致索引错位。

在 JavaScript 中，数组解构赋值（如 [a[0], a[1]] = [a[1], a[0]]）看似简洁，但其执行过程严格遵循“右值先行求值 → 左值依次赋值”的规则。当索引本身依赖数组当前状态（例如 a[a[0]]）时，这一机制就会引发隐式副作用。

以你的示例为例：

let a = [1, 0];
[a[0], a[a[0]]] = [a[a[0]], a[0]];
console.log(a); // 输出 [1, 0] —— 未发生预期交换

我们逐步拆解执行流程：

1. 右侧先求值：
   a[a[0]] → a[1] → 0；a[0] → 1；
   右侧结果为 [0, 1]（一个临时数组）。

2. 左侧依次赋值：

   立即学习“Java免费学习笔记（深入）”；

   • 第一步：a[0] = 0 → a 变为 [0, 0]；
   • 第二步：计算 a[a[0]] → 此时 a[0] 已是 0，所以 a[a[0]] 等价于 a[0]；
     因此 a[a[0]] = 1 实际执行的是 a[0] = 1 → a 变回 [1, 0]。

最终效果等同于：

Alibabacloud Sdk Client Initialization For Java

在 Java 中初始化和管理阿里云 SDK客户端。包括单例模式、线程安全、endpoint 与 region 配置、VPC 终端节点、同步与异步等。

下载

a[0] = 0;
a[0] = 1; // 覆盖前一步，a[0] 被重写

✅ 对比成功案例：

let a = [1, 0];
[a[0], a[1]] = [a[1], a[0]]; // 右侧 → [0, 1]；左侧 → a[0]=0, a[1]=1
console.log(a); // [0, 1] ✅

此处索引 0 和 1 是静态常量，不受赋值过程影响，因此行为可预测。

✅ 正确做法：避免动态索引参与解构左侧

若需交换 a[i] 与 a[a[i]]，应预先缓存索引和值，再分步赋值：

let a = [1, 0];
const i = 0;
const targetIndex = a[i];        // 缓存原始 a[i] → 1
const valI = a[i];               // = a[0] → 1
const valTarget = a[targetIndex]; // = a[1] → 0

// 安全交换（无副作用）
a[i] = valTarget;
a[targetIndex] = valI;

console.log(a); // [0, 1] ✅

或封装为复用函数：

function swapByIndex(arr, i) {
  const j = arr[i];
  if (j < 0 || j >= arr.length || i < 0 || i >= arr.length) {
    throw new RangeError('Index out of bounds');
  }
  [arr[i], arr[j]] = [arr[j], arr[i]];
}

⚠️ 注意事项：

• 解构赋值不适用于左侧含副作用表达式（如 a[a[0]], a[++i], obj.keys()[0] 等）；
• 所有左侧属性访问（a[...]）在赋值时实时计算，且受此前赋值影响；
• 若逻辑复杂，优先选择显式临时变量——清晰、安全、易调试。

总结：解构赋值是语法糖，不是原子操作。信任它处理静态位置，但对动态/依赖状态的索引，请回归明确的中间变量控制流。