4

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

  1. 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。当断言被触发时，GString 被求值并使用 toString 将 1 转换为 String。当我们将 x 更改为 2 时，我们确实更改了 x 的值，但它是一个不同的对象，GString 仍然引用旧的。

只有当 GString 引用的值发生变化时，GString 才会更改其 toString 表示。如果引用发生变化，什么都不会发生。

我的问题是关于上面引用的解释，在示例代码中，1 显然是一个值，而不是引用类型，那么如果这个陈述是真的，它应该在 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 的值，创建 String 时 p 的值是 'Sam'

因此我认为它不应该在这里改变？感谢您的帮助。

4

2 回答 2

6

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

<org.codehaus.groovy.runtime.GStringImpl@6aa798b strings=[x = , ] values=[1]>

数组中的一个对象和数组String中的一个对象都是不可变的。（值是不可变的，而不是数组。）当变量被分配给一个新值时，它会在内存中创建一个与存储在数组中的对象无关的新对象。不是突变。这是新对象的创建。这不是 Groovy 特有的东西，这就是 Java 的工作方式。您可以尝试下面的纯 Java 示例，看看它是如何工作的：stringsIntegervaluesx1GString.valuesx = 2

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添加到. 当您通过向其添加新数字来改变列表时，这些更改会反映在 中，因为您改变了内存中可以访问的对象。但是当你用一个新列表覆盖时，你会创建一个新对象，并且与内存中的这个新对象没有任何联系。您可以将整数添加到这个新列表并且不会受到影响 - 它在内存中存储对不同对象的引用。（以前可以使用变量引用的对象，但后来在代码中用新对象覆盖了这个引用。）nestednestedlist2nestedlist2list2nestedlist2nestedlist2nested

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

于 2020-04-15T11:37:18.813 回答
3

这几乎是整个故事，因为您可以使用闭包来进行 GString 评估，所以不要只使用变量：

def gs = "x = ${x}"

您可以使用返回变量的闭包：

def gs = "x = ${-> x}"

这意味着x在将 GString 更改为字符串时评估该值，因此这将起作用（来自原始问题）

def x = 1
def gs = "x = ${-> x}"
assert gs == 'x = 1'
x = 2
assert gs == 'x = 2'
于 2020-04-15T13:06:31.633 回答