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

Question

最近我遇到了这样一个问题：作业操作员链理解。

在回答这个问题时，我开始怀疑自己对加法赋值运算符=或任何其他运算符=（

我的问题是，下面表达式中的变量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。

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




Answer 1

它只是使用了ops顺序的变化。

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

彭达斯：

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=24

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);

Answer 2

以下是需要注意的规则

>

运算符优先级

变量赋值

表达式求值

表达式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

匿名用户

请记住，a=x真正的意思是a=ax。要理解的关键点是加法是从左到右求值的——也就是说，a x中的a在x之前求值。

那么让我们看看b=（a=（a=a））做了什么。首先，我们使用规则a=x表示a=ax，然后开始按照正确的顺序仔细计算表达式：

• b=（a=a（a=a））因为a=x表示a=a x
• b=（a=1（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是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=aa）（a=aa）
• b=（a=11）（a=aa），记住我们先计算左项，再计算右项
• b=（a=2）（a=a）
• b=2（a=aa）而a现在是2。开始评估正确的术语
• b=2（a=22）
• b=2（a=4）
• b=24和a现在是4
• b=6

这就剩下a=4和b=6了。这可以通过在Java /JavaScript中打印出a和b来验证（两者在这里具有相同的行为）。

将这些表达式看作解析树也可能有所帮助。当我们评估a（bc）时，在RHS（bc）之前评估LHSa。这在树结构中编码：

   +
  / \
 a   +
    / \
   b   c

注意，我们不再有任何括号了——操作顺序被编码到树结构中。当我们评估树中的节点时，我们按照固定的顺序处理节点的子节点（即从左到右处理）。例如，当我们处理根节点时，我们在右子树（bc）之前计算左子树a，而不管右子树是否包含在括号中（因为括号甚至不在解析树中）。

正因为如此，Java/JavaScript并不总是首先计算“最嵌套的括号”，这与您可能学习的算术规则不同。

请参阅Java语言规范：

Java编程语言保证运算符的操作数以特定的计算顺序计算，即从左到右。
...

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

如果运算符是复合赋值运算符（§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。