闭包
捕获状态
闭包 是 CoddyKit 上的免费 Scala for Backend Engineering & Functional Programming 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Scala for Backend Engineering & Functional Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。
什么是闭包
闭包是一个函数，它捕获了定义它时所在外部作用域中的变量。它会“封闭”这些变量，即使该作用域已经返回，仍然可以访问这些变量。
object Main {
def main(args: Array[String]): Unit = {
val factor = 3
val multiply = (x: Int) => x * factor
println(multiply(5))
}
}捕获自由变量
在 x => x * factor 中，x 是参数，而 factor 是从外层作用域取得的自由变量。该函数会携带对它的引用。
object Main {
def main(args: Array[String]): Unit = {
val greeting = "Hello"
val greet = (name: String) => s"$greeting, $name!"
println(greet("Ann"))
println(greet("Bob"))
}
}闭包的生命周期超出其作用域
当一个函数返回闭包时，只要闭包仍然存在，被捕获的变量就会继续存活，即使定义它的函数已经执行完毕。
object Main {
def makeAdder(n: Int): Int => Int = x => x + n
def main(args: Array[String]): Unit = {
val add10 = makeAdder(10)
val add100 = makeAdder(100)
println(add10(5))
println(add100(5))
}
}每个闭包都有自己的捕获内容
调用函数工厂两次会生成两个彼此独立的闭包，每个闭包都会记住自己捕获的值。
object Main {
def prefixer(p: String): String => String = s => p + s
def main(args: Array[String]): Unit = {
val withDr = prefixer("Dr. ")
val withMr = prefixer("Mr. ")
println(withDr("Smith"))
println(withMr("Jones"))
}
}捕获可变状态
闭包可以捕获一个 var，并对它进行读取和更新。这样，闭包就能在多次调用之间维护状态，例如维护一个计数器。
object Main {
def main(args: Array[String]): Unit = {
var count = 0
val increment = () => { count += 1; count }
println(increment())
println(increment())
println(increment())
}
}计数器工厂
把这些概念结合起来：让一个函数返回一个捕获自身私有 var 的闭包，就可以得到一个封装且独立的计数器。
object Main {
def counter(): () => Int = {
var n = 0
() => { n += 1; n }
}
def main(args: Array[String]): Unit = {
val c1 = counter()
val c2 = counter()
println(c1())
println(c1())
println(c2())
}
}闭包捕获的是引用，而不是副本
闭包捕获的是变量，而不是快照。如果被捕获的 var 在闭包创建后发生变化，闭包就会看到新值。
object Main {
def main(args: Array[String]): Unit = {
var msg = "first"
val show = () => println(msg)
show()
msg = "second"
show()
}
}优先捕获 val
捕获不可变的 val 可以避免意外：被捕获的值永远不会改变，因此闭包的行为更容易预测。在函数式代码中，请优先捕获 val。
object Main {
def main(args: Array[String]): Unit = {
val taxRate = 0.2
val withTax = (price: Double) => price * (1 + taxRate)
println(withTax(100))
}
}闭包与集合方法
传给 map、filter 等方法的 lambda，只要引用了外部变量，就属于闭包。这在日常 Scala 编程中非常常见。
object Main {
def main(args: Array[String]): Unit = {
val threshold = 3
val nums = List(1, 2, 3, 4, 5)
val big = nums.filter(_ > threshold)
println(big)
}
}循环中的捕获陷阱
在 Scala 中，for 循环变量在每次迭代时都会产生新的绑定，因此闭包捕获的是彼此不同的值。这避免了其他一些语言中常见的经典错误。
object Main {
def main(args: Array[String]): Unit = {
val fns = for (i <- 1 to 3) yield () => i
println(fns.map(f => f()))
}
}闭包封装行为与数据
闭包将行为（函数体）与数据（被捕获的变量）打包在一起。这是一种轻量的替代方案，可以代替只有一个方法的小对象。
object Main {
def discounter(rate: Double): Double => Double = price => price * (1 - rate)
def main(args: Array[String]): Unit = {
val sale = discounter(0.25)
println(sale(80))
println(sale(200))
}
}快速检查
闭包会从其周围的作用域中捕获什么？
回顾
您已经了解了闭包：
- 闭包会从外层作用域捕获自由变量
- 被捕获的变量的生命周期会超出定义它的函数
- 每个闭包实例都有自己的捕获状态
- 闭包捕获的是引用，因此可变的捕获内容可能发生变化
- 传给
map/filter的 lambda 都是日常使用的闭包
常见问题解答
「闭包」课时是免费的吗？
是的 — 「闭包」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Scala for Backend Engineering & Functional Programming 课程的其余内容，请升级到 CoddyKit PRO。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。
「闭包」这节课中我会学到什么？
捕获状态 你通过在浏览器中直接运行的动手代码来练习 Scala for Backend Engineering & Functional Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Scala for Backend Engineering & Functional Programming 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Scala for Backend Engineering & Functional Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。
「闭包」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Scala for Backend Engineering & Functional Programming 课中编写并运行代码吗？
能。每节 Scala for Backend Engineering & Functional Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。