加法赋值 += 表达式中的行为

Question

最近遇到一个问题：Assignment operator chain understanding。

在回答这个问题时，我开始怀疑自己对加法赋值运算符 += 或任何其他 operator=（&=、*=、/= 等）的行为的理解。

我的问题是，下面表达式中的变量a是什么时候更新到原位的，使其变化的值在求值时反映到表达式中的其他地方，其背后的逻辑是什么？请看下面两个表达式：

表达式 1

a = 1
b = (a += (a += a))
//b = 3 is the result, but if a were updated in place then it should've been 4

表达式 2

a = 1
b = (a += a) + (a += a)
//b = 6 is the result, but if a is not updated in place then it should've been 4

在第一个表达式中，当计算最里面的表达式(a += a)时，它似乎没有更新a的值，因此结果是3而不是4。

但是，在第二个表达式中，a 的值被更新，因此结果为 6。

我们什么时候应该假设a的值会反映在表达式的其他地方，什么时候不应该？

Answer 1

请记住，a += x 的真正含义是 a = a + x。要理解的关键点是加法是从左到右计算的——即a + x中的a在x之前计算。

所以让我们弄清楚b = (a += (a += a)) 做了什么。首先我们使用规则a += x 表示a = a + x，然后我们开始以正确的顺序仔细评估表达式：

• b = (a = a + (a = a + a)) 因为a += x 表示a = a + x
• b = (a = 1 + (a = a + a)) 因为a 当前是1。请记住，我们在右项 (a = a + a) 之前评估左项 a
• b = (a = 1 + (a = 1 + a)) 因为 a 仍然是 1
• b = (a = 1 + (a = 1 + 1)) 因为a 仍然是1
• b = (a = 1 + (a = 2)) 因为1 + 1 是2
• b = (a = 1 + 2) 因为 a 现在是 2
• b = (a = 3) 因为1 + 2 是3
• b = 3 因为 a 现在是 3

如上所述，这给我们留下了a = 3 和b = 3。

让我们试试另一个表达式b = (a += a) + (a += a)：

• b = (a = a + a) + (a = a + a)
• b = (a = 1 + 1) + (a = a + a)，请记住我们先评估左侧术语，然后评估右侧术语
• b = (a = 2) + (a = a + a)
• b = 2 + (a = a + a) 和 a 现在是 2。开始评估正确的术语
• b = 2 + (a = 2 + 2)
• b = 2 + (a = 4)
• b = 2 + 4 和 a 现在是 4
• b = 6

这给我们留下了a = 4 和b = 6。这可以通过在 Java/JavaScript 中打印出 a 和 b 来验证（此处两者的行为相同）。

---

将这些表达式视为解析树也可能会有所帮助。当我们评估 a + (b + c) 时，LHS a 在 RHS (b + c) 之前被评估。这是在树结构中编码的：

   +
  / \
 a   +
    / \
   b   c

请注意，我们不再有任何括号 - 操作顺序被编码到树结构中。当我们评估树中的节点时，我们以固定顺序处理节点的子节点（即，+ 从左到右）。例如，当我们处理根节点+ 时，我们在右子树(b + c) 之前评估左子树a，而不管右子树是否包含在括号中（因为括号甚至不存在在解析树中）。

因此，Java/JavaScript不总是首先评估“嵌套最多的括号”，这与您可能学过的算术规则相反。

见Java Language Specification：

15.7。评估顺序

Java 编程语言保证运算符的操作数看起来是按照特定的求值顺序进行求值的，即从左到右。
...

15.7.1。首先计算左手操作数

二元运算符的左侧操作数似乎在右侧操作数的任何部分被评估之前已被完全评估。

如果运算符是复合赋值运算符（第 15.26.2 节），则左侧操作数的评估包括记住左侧操作数表示的变量以及获取和保存该变量的值以用于隐含二元运算。

更多类似你问题的例子可以在JLS的链接部分找到，例如：

示例 15.7.1-1。首先计算左手操作数

在下面的程序中，* 运算符有一个左操作数 包含对变量的赋值和右侧操作数 包含对同一变量的引用。所产生的价值 引用将反映分配首先发生的事实。

class Test1 {
    public static void main(String[] args) {
        int i = 2;
        int j = (i=3) * i;
        System.out.println(j);
    }
}

这个程序产生输出：

9

不允许对 * 运算符的求值产生 6 而不是 9。

Answer 2

以下是需要注意的规则

• Operator precedence
• 变量赋值

• 表达式评估

  表达式 1

  a = 1
  b = (a += (a += a))
  
  b = (1 += (a += a))  // a = 1
  b = (1 += (1 += a))  // a = 1
  b = (1 += (1 += 1))  // a = 1
  b = (1 += (2))  // a = 2 (here assignment is -> a = 1 + 1)
  b = (3)  // a = 3 (here assignment is -> a = 1 + 2)
  

  表达式 2

  a = 1
  b = (a += a) + (a += a)
  
  b = (1 += a) + (a += a) // a = 1
  b = (1 += 1) + (a += a) // a = 1
  b = (2) + (a += a) // a = 2 (here assignment is -> a = 1 + 1)
  b = (2) + (2 += a) // a = 2 (here here a = 2)
  b = (2) + (2 += 2) // a = 2
  b = (2) + (4) // a = 4 (here assignment is -> a = 2 + 2)
  b = 6 // a = 4
  

  表达式 3

  a = 1
  b = a += a += a += a += a
  
  b = 1 += 1 += 1 += 1 += 1 // a = 1
  b = 1 += 1 += 1 += 2 // a = 2 (here assignment is -> a = 1 + 1)
  b = 1 += 1 += 3 // a = 3 (here assignment is -> a = 1 + 2)
  b = 1 += 4 // a = 4 (here assignment is -> a = 1 + 3)
  b = 5 // a = 5 (here assignment is -> a = 1 + 4)
  

Answer 3

它只是使用了操作顺序的变体。

如果您需要提醒操作顺序：

PEMDAS：

P = 括号

E = 指数

MD = 乘法/除法

AS = 加法/减法

其余的从左到右。

这种变化只是从左到右阅读，但如果你看到括号内的所有内容，并将其替换为常量，然后继续。

第一个例子：

var b = (a+=(a+=a))

var b = (1+=(1+=1))

var b = (1+=2)

var b = 3

第二个例子：

var b = (a+=a)+(a+=a)

var b = (1+=1)+(a+=a)

var b = 2 + (2+=2)

var b = 2 + 4

var b = 6

var a = 1
var b = (a += (a += a))
console.log(b);

a = 1
b = (a += a) + (a += a)
console.log(b);

a = 1
b = a += a += a;
console.log(b);

最后一个b = a += a += a，因为没有括号，自动变成b = 1 += 1 += 1，即b = 3