Groovy 闭包：{} 闭包与 it 变量

Groovy 作为 JVM 平台上一门灵活的动态语言，其闭包（Closure）特性堪称最强大的特性之一。闭包本质上是一段可执行的代码块，它可以被赋值给变量、作为参数传递、在需要时调用执行。掌握闭包的写法以及 it 变量的使用规律，能让你的 Groovy 代码更加简洁优雅。

闭包的基本语法

Groovy 使用一对大括号 {} 来定义闭包。这是闭包最显著的语法特征，与其他语言中常见的 -> 或 fn() 写法有明显区别。

最简单的闭包形式

空参数的闭包直接在大括号内写执行逻辑：

def greet = { println "Hello, Groovy!" }
greet()  // 输出: Hello, Groovy!

调用闭包的方式与调用函数完全相同，使用圆括号并传入实际参数（如果有的话）。上面的例子中，闭包内部直接执行了 println 语句，没有显式引用任何参数。

带参数的闭包定义

闭包可以接收一个或多个参数，参数定义在 -> 符号左侧：

def double = { x -> x * 2 }
println double(5)  // 输出: 10

当闭包只有一个参数时，Groovy 提供了一个默认变量 it 来引用该参数，无需显式声明参数名。这是 Groovy 闭包最便利的语法糖，也是本文的核心内容。

it 变量详解

it 是 Groovy 闭包中的一个隐式变量，专门用于简化单参数闭包的写法。当你定义一个接受单个参数的闭包却不显式声明参数名称时，Groovy 会自动创建一个名为 it 的变量来代表传入的实际参数。

使用 it 的标准写法

下面展示两种等价的闭包定义方式：

// 显式声明参数
def square1 = { x -> x * x }

// 使用 it 隐式参数
def square2 = { it * it }

println square1(4)  // 输出: 16
println square2(4)  // 输出: 16

两种写法的执行结果完全一致，但使用 it 的版本更加简洁，省去了参数声明的步骤。对于简单的一行逻辑，这种写法能显著减少代码冗余。

it 的作用域规则

it 变量只在闭包内部有效，它始终指向当前调用时传入的第一个参数。理解这一点至关重要：如果闭包接收多个参数，it 依然只代表第一个参数，其他参数必须显式声明名称。

// 多参数闭包：it 仅代表第一个参数
def multiply = { a, b -> a * b }
println multiply(3, 4)  // 输出: 12
// 此时闭包内部没有使用 it，因为两个参数都需要使用

当闭包没有参数时，it 变量不存在，此时只能使用空参数列表或显式声明的参数（如果需要的话）。

it 的典型使用场景

集合操作中的 it

Groovy 的集合 API 大幅依赖闭包作为参数，而 it 在这些场景中使用频率最高。处理列表、映射等数据结构时，it 能让你的代码保持简洁。

def numbers = [1, 2, 3, 4, 5]

// each: 遍历每个元素
numbers.each { println it }

// collect: 转换每个元素并收集结果
def doubled = numbers.collect { it * 2 }
println doubled  // 输出: [2, 4, 6, 8, 10]

// findAll: 筛选满足条件的元素
def evens = numbers.findAll { it % 2 == 0 }
println evens  // 输出: [2, 4]

// any / every: 判断是否存在/全部满足
println numbers.any { it > 3 }  // 输出: true
println numbers.every { it < 10 }  // 输出: true

上述代码展示了集合操作中最常用的四个方法。each 用于遍历，collect 用于映射转换，findAll 用于过滤筛选，any 和 every 用于条件判断。所有这些方法的闭包参数都使用了 it，因为它们的核心逻辑都是针对单个元素进行处理。

映射操作中的 it

处理映射（Map）时，闭包的参数结构略有不同。映射的 each 方法传入的是一个包含键值对的 Map.Entry 对象：

def scores = ["Alice": 85, "Bob": 92, "Charlie": 78]

// 遍历映射：it 代表 Map.Entry
scores.each { println "${it.key}: ${it.value}" }

// 筛选：it 同样是 Map.Entry
def highScores = scores.findAll { it.value >= 80 }
println highScores  // 输出: [Alice:85, Bob:92]

如果你更习惯分别处理键和值，可以显式声明两个参数来替代 it：

scores.each { name, score -> 
    println "${name}: ${score}" 
}

字符串处理中的 it

Groovy 为字符串提供了很多接受闭包的方法，it 在这些场景中同样发挥作用：

def text = "Groovy is awesome"

// eachMatch: 找出所有匹配项
def matches = []
text.eachMatch(/\\w+/) { matches << it }
println matches  // 输出: [Groovy, is, awesome]

// replaceAll: 替换匹配内容
def result = text.replaceAll(/\\w+/) { it.toUpperCase() }
println result  // 输出: GROOVY IS AWESOME

replaceAll 的闭包中，it 匹配到的是每个正则表达式匹配到的子串，你可以对它进行任意处理后再作为替换结果返回。

it 与显式参数的选择

使用 it 的情况

当闭包逻辑简单、参数只被使用一两次时，it 是最佳选择。它能让代码保持紧凑，减少不必要的变量名噪音。

// 推荐：使用 it
def cube = { it * it * it }

// 推荐：集合操作的通用模式
list.collect { it.trim().toLowerCase() }

使用显式参数的情况

当闭包逻辑较复杂、参数需要多次使用或含义不直观时，显式声明参数名能提高代码可读性：

// 推荐：参数含义需要说明时
def formatUser = { user -> 
    def displayName = user?.name ?: "Anonymous"
    def displayAge = user?.age ?: 0
    return "${displayName} (${displayAge} years old)"
}

// 推荐：参数在闭包内多次使用时
def calculateDiscount = { originalPrice, discountRate ->
    def discountAmount = originalPrice * discountRate
    def finalPrice = originalPrice - discountAmount
    return finalPrice
}

显式参数名还能避免 IDE 警告和潜在的多线程问题。在某些并发场景下，隐式 it 变量的行为可能不如显式参数稳定。

多参数闭包必须显式声明

这是最重要的一条规则：接受两个及以上参数的闭包不能使用 it，必须显式声明所有参数名称：

// 错误：多参数闭包无法使用 it
// def badExample = { it + 10 }  // 不适用于多参数

// 正确：显式声明所有参数
def add = { a, b -> a + b }
def applyOperation = { x, y, operation -> operation(x, y) }

常见误区与注意事项

误区一：混淆 it 与其他上下文变量

it 只在闭包定义时有效，它指向调用时传入的第一个实参。闭包外部的 it（如果有的话）与闭包内部的 it 没有任何关系：

def outer = "outer"
def closure = { println it }

outer.eachLine { line -> 
    // 这里的 it 是 eachLine 传入的行内容
    // 与 outer 变量无关
}

误区二：在空参数闭包中使用 it

空参数闭包没有 it 变量，尝试使用会导致运行时错误：

// 错误示例
def bad = { println it }  // 调用时无参数，it 未定义

// 正确示例
def good = { println "no parameters" }

误区三：过度使用 it 导致可读性下降

it 虽然简洁，但滥用会降低代码可读性。特别是当闭包包含多步逻辑时，显式的参数名能让代码自文档化：

// 不推荐：逻辑复杂时仍使用 it
data.collect { 
    def cleaned = it.trim()
    def normalized = cleaned.toLowerCase()
    def hashed = normalized.md5()
    hashed
}

// 推荐：使用有意义的参数名
data.collect { rawInput ->
    def cleaned = rawInput.trim()
    def normalized = cleaned.toLowerCase()
    def hashed = normalized.md5()
    hashed
}

最佳实践总结

在日常 Groovy 开发中，遵循以下原则能让你的闭包代码既简洁又清晰：

优先使用 it 的场景包括：集合的 each、collect、findAll、any、every 等方法；简单的转换逻辑；单行 lambda 表达式。

改用显式参数的场景包括：闭包接收两个及以上参数；参数在闭包内被多次使用；闭包逻辑较复杂需要自文档化；团队编码规范要求显式声明。

无论选择哪种写法，保持一致性比选择本身更重要。在同一个项目或模块中，采用统一的闭包风格能显著提升代码的可维护性。