GString何时更改其toString表示形式

Question

我正在阅读https://groovy-lang.org/closures.html#this中的Groovy闭包文档。对GString行为有疑问。

4. GString中的关闭

该文件提及以下内容：

采用以下代码：

def x = 1
def gs = "x = ${x}"
assert gs == 'x = 1'

代码的行为符合您的预期，但是如果添加，会发生什么：

x = 2
assert gs == 'x = 2'

您将看到断言失败！这有两个原因：

一个GString只懒惰地计算值的toString表示形式

GString中的语法$ {x}并不表示闭包，而是$ x的表达式，该表达式在创建GString时进行评估。

在我们的示例中，GString是使用引用x的表达式创建的。创建GString时，x的值为1，因此创建的GString值为1。触发assert时，将评估GString并使用toString将1转换为String。当我们将x更改为2时，我们确实更改了x的值，但这是一个不同的对象，并且GString仍引用旧的对象。

GString仅在其引用的值发生突变时才会更改其toString表示形式。如果引用发生更改，则不会发生任何事情。

我的问题是关于上面引用的解释，在示例代码中，1显然是一个值，而不是引用类型，那么如果此语句为true，则应在GString中将其更新为2，对吗？

下面列出的下一个示例我也感到困惑（最后一部分）为什么我们将Sam突变为他的名字改成Lucy，这次GString正确地突变了？我希望它不会变异？为什么两个示例中的行为如此不同？

class Person {
    String name
    String toString() { name }          
}

def sam = new Person(name:'Sam')        
def lucy = new Person(name:'Lucy')      
def p = sam                             
def gs = "Name: ${p}"                   
assert gs == 'Name: Sam'                
p = Lucy. //if we change p to Lucy                                
assert gs == 'Name: Sam'   // the string still evaluates to Sam because it was the value of p when the GString was created
/* I would expect below to be 'Name: Sam' as well 
 * if previous example is true. According to the     
 * explanation mentioned previously. 
 */         
sam.name = 'Lucy' // so if we mutate Sam to change his name to Lucy                  
assert gs == 'Name: Lucy'  // this time the GString is correctly mutated

为什么评论说'这次GString被正确地突变了？在之前的评论中，它只是提及

字符串仍然计算为Sam，因为创建GString时它是p的值，创建字符串时p的值是'Sam'

因此，我认为这里不应更改？？感谢您的帮助。

Answer 1

这两个示例解释了两个不同的用例。在第一个示例中，表达式"x = ${x}"创建一个GString对象，该对象在内部存储strings = ['x = ']和values = [1]。您可以使用GString检查此特定println gs.dump()的内部：

<org.codehaus.groovy.runtime.GStringImpl@6aa798b strings=[x = , ] values=[1]>
两个对象，String数组中的strings个和Integer数组中的values都是不可变

。 （值是不可变的，不是数组。）将x变量分配给新值后，它将在内存中创建一个与存储在1数组中的GString.values不相关的新对象。 x = 2不是突变。这是新对象的创建。这不是Groovy特有的事情，而是Java的工作方式。您可以尝试下面的纯Java示例以了解其工作原理：

List<Integer> list = new ArrayList<>();
Integer number = 2;
list.add(number);

number = 4;

System.out.println(list); // prints: [2]
Person类的用例是不同的。在这里，您可以看到对象的变异是如何工作的。当您将sam.name更改为Lucy时，将对GString.values数组中存储的对象的内部阶段进行突变。如果您改为创建一个新对象并将其分配给sam变量（例如sam = new Person(name:"Adam")），则不会影响现有GString对象的内部。内部存储在GString中的对象未发生突变。在这种情况下，变量sam仅引用内存中的另一个对象。当您执行sam.name = "Lucy"时，会在内存中对对象进行突变，因此GString（使用对同一对象的引用）会看到此更改。它类似于以下普通的Java用例：

List<List<Integer>> list2 = new ArrayList<>();

List<Integer> nested = new ArrayList<>();
nested.add(1);

list2.add(nested);
System.out.println(list2); // prints: [[1]]

nested.add(3);

System.out.println(list2); // prints: [[1,3]]

nested = new ArrayList<>();

System.out.println(list2); // prints: [[1,3]]
[您可以看到，当list2添加到nested时，nested将对象的引用存储在由list2变量表示的存储器中。当通过添加新数字对nested列表进行突变时，这些更改会反映在list2中，因为您对list2可以访问的内存中的对象进行了突变。但是，当用新列表覆盖nested时，会创建一个新对象，并且list2与内存中的该新对象没有任何关系。您可以在此新的nested列表中添加整数，并且list2不会受到影响-它在内存中存储了对另一个对象的引用。 （以前可以使用nested变量来引用该对象，但是稍后在代码中使用新对象覆盖了此引用。）

GString在这种情况下的行为类似于上面显示的带有清单的示例。如果您更改插值对象的状态（例如sam.name，或在nested列表中添加整数），则此更改将反映在GString.toString()中，该方法在调用该方法时会产生字符串。 （创建的字符串使用values内部数组中存储的值的当前状态。）另一方面，如果使用新对象（例如x = 2，sam = new Person(name:"Adam")或nested = new ArrayList()）覆盖变量， ），它不会更改GString.toString()方法产生的内容，因为它仍然使用存储在内存中的一个或多个对象，并且该对象先前与您分配给新对象的变量名称相关联。

Answer 2

这就是几乎