Scala 闭包

闭包（Closure）是函数式编程中的一个重要概念。在 Scala 中，闭包是一个函数，它可以访问其定义时所在作用域中的变量，即使在该作用域之外调用该函数时也是如此。

什么是闭包

闭包是一个函数值，它引用了其函数体外部的一个或多个变量。这些被引用的变量被称为"自由变量"。

基本闭包示例

scala

object BasicClosure {
  def main(args: Array[String]): Unit = {
    var factor = 3
    
    // 这是一个闭包，它捕获了外部变量 factor
    val multiplier = (x: Int) => x * factor
    
    println(multiplier(10))  // 输出: 30
    
    // 修改外部变量
    factor = 5
    println(multiplier(10))  // 输出: 50
    
    // 闭包捕获的是变量的引用，而不是值
    var counter = 0
    val increment = () => {
      counter += 1
      counter
    }
    
    println(increment())  // 1
    println(increment())  // 2
    println(increment())  // 3
    println(s"Counter value: $counter")  // 3
  }
}

闭包 vs 普通函数

scala

object ClosureVsFunction {
  def main(args: Array[String]): Unit = {
    // 普通函数 - 不依赖外部变量
    def add(x: Int, y: Int): Int = x + y
    
    // 闭包 - 依赖外部变量
    val base = 10
    val addToBase = (x: Int) => x + base
    
    println(add(5, 3))        // 8
    println(addToBase(5))     // 15
    
    // 函数字面量（匿名函数）
    val square = (x: Int) => x * x
    println(square(4))        // 16
    
    // 带有自由变量的闭包
    var multiplier = 2
    val multiplyBy = (x: Int) => x * multiplier
    
    println(multiplyBy(5))    // 10
    multiplier = 3
    println(multiplyBy(5))    // 15
  }
}

闭包的创建和使用

返回闭包的函数

scala

object ClosureFactory {
  // 返回闭包的函数
  def makeAdder(increment: Int): Int => Int = {
    (x: Int) => x + increment
  }
  
  def makeMultiplier(factor: Int): Int => Int = {
    (x: Int) => x * factor
  }
  
  // 更复杂的闭包工厂
  def makeCounter(start: Int = 0): () => Int = {
    var count = start
    () => {
      count += 1
      count
    }
  }
  
  def main(args: Array[String]): Unit = {
    // 创建不同的加法器
    val add5 = makeAdder(5)
    val add10 = makeAdder(10)
    
    println(add5(3))   // 8
    println(add10(3))  // 13
    
    // 创建不同的乘法器
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)
    
    println(double(4))  // 8
    println(triple(4))  // 12
    
    // 创建计数器
    val counter1 = makeCounter()
    val counter2 = makeCounter(100)
    
    println(counter1())  // 1
    println(counter1())  // 2
    println(counter2())  // 101
    println(counter2())  // 102
  }
}

闭包作为参数

scala

object ClosureAsParameter {
  // 接受闭包作为参数的函数
  def applyOperation(numbers: List[Int], operation: Int => Int): List[Int] = {
    numbers.map(operation)
  }
  
  def filterNumbers(numbers: List[Int], predicate: Int => Boolean): List[Int] = {
    numbers.filter(predicate)
  }
  
  // 高阶函数示例
  def processData[T](data: List[T], processor: T => T, filter: T => Boolean): List[T] = {
    data.filter(filter).map(processor)
  }
  
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // 使用闭包进行操作
    val threshold = 5
    val multiplier = 2
    
    // 创建闭包
    val isGreaterThanThreshold = (x: Int) => x > threshold
    val multiplyByFactor = (x: Int) => x * multiplier
    
    // 应用闭包
    val filtered = filterNumbers(numbers, isGreaterThanThreshold)
    val transformed = applyOperation(numbers, multiplyByFactor)
    
    println(s"原始数据: $numbers")
    println(s"大于 $threshold 的数: $filtered")
    println(s"乘以 $multiplier: $transformed")
    
    // 组合操作
    val processed = processData(numbers, multiplyByFactor, isGreaterThanThreshold)
    println(s"先过滤再变换: $processed")
  }
}

闭包的高级用法

柯里化和闭包

scala

object CurryingAndClosures {
  // 柯里化函数
  def add(x: Int)(y: Int): Int = x + y
  
  // 使用闭包实现柯里化
  def addClosure(x: Int): Int => Int = (y: Int) => x + y
  
  // 更复杂的柯里化示例
  def calculate(operation: String)(x: Double)(y: Double): Double = {
    operation match {
      case "add" => x + y
      case "subtract" => x - y
      case "multiply" => x * y
      case "divide" => if (y != 0) x / y else throw new IllegalArgumentException("Division by zero")
      case _ => throw new IllegalArgumentException("Unknown operation")
    }
  }
  
  def main(args: Array[String]): Unit = {
    // 柯里化函数的使用
    val add5 = add(5) _  // 部分应用
    println(add5(3))     // 8
    
    // 闭包实现的柯里化
    val addClosure5 = addClosure(5)
    println(addClosure5(3))  // 8
    
    // 复杂柯里化的使用
    val addOperation = calculate("add") _
    val multiplyOperation = calculate("multiply") _
    
    val add10 = addOperation(10) _
    val multiplyBy3 = multiplyOperation(3) _
    
    println(add10(5))        // 15
    println(multiplyBy3(4))  // 12
  }
}

闭包和集合操作

scala

object ClosuresWithCollections {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val words = List("scala", "java", "python", "javascript", "go")
    
    // 使用闭包进行过滤
    val minLength = 4
    val longWords = words.filter(_.length >= minLength)
    println(s"长度至少为 $minLength 的单词: $longWords")
    
    // 使用闭包进行变换
    val prefix = "lang_"
    val prefixedWords = words.map(prefix + _)
    println(s"添加前缀: $prefixedWords")
    
    // 使用闭包进行聚合
    val threshold = 5
    val (small, large) = numbers.partition(_ < threshold)
    println(s"小于 $threshold: $small")
    println(s"大于等于 $threshold: $large")
    
    // 复杂的闭包操作
    val multiplier = 2
    val filter = 3
    val result = numbers
      .filter(_ % filter == 0)
      .map(_ * multiplier)
      .reduce(_ + _)
    
    println(s"能被 $filter 整除的数乘以 $multiplier 后的和: $result")
  }
}

闭包和状态管理

scala

object ClosureStateManagement {
  // 使用闭包创建私有状态
  def createBankAccount(initialBalance: Double): (String, Double) => Double = {
    var balance = initialBalance
    
    (operation: String, amount: Double) => {
      operation match {
        case "deposit" =>
          balance += amount
          balance
        case "withdraw" =>
          if (amount <= balance) {
            balance -= amount
            balance
          } else {
            throw new IllegalArgumentException("Insufficient funds")
          }
        case "balance" =>
          balance
        case _ =>
          throw new IllegalArgumentException("Unknown operation")
      }
    }
  }
  
  // 创建计数器工厂
  def createCounter(): (String) => Int = {
    var count = 0
    
    (operation: String) => {
      operation match {
        case "increment" => 
          count += 1
          count
        case "decrement" => 
          count -= 1
          count
        case "reset" => 
          count = 0
          count
        case "get" => 
          count
        case _ => 
          throw new IllegalArgumentException("Unknown operation")
      }
    }
  }
  
  def main(args: Array[String]): Unit = {
    // 银行账户示例
    val account = createBankAccount(1000.0)
    
    println(s"初始余额: ${account("balance", 0)}")
    println(s"存款 500: ${account("deposit", 500)}")
    println(s"取款 200: ${account("withdraw", 200)}")
    println(s"当前余额: ${account("balance", 0)}")
    
    // 计数器示例
    val counter = createCounter()
    
    println(s"初始计数: ${counter("get")}")
    println(s"递增: ${counter("increment")}")
    println(s"递增: ${counter("increment")}")
    println(s"递减: ${counter("decrement")}")
    println(s"当前计数: ${counter("get")}")
    println(s"重置: ${counter("reset")}")
  }
}

闭包的实际应用

事件处理

scala

object EventHandling {
  case class Event(name: String, data: Map[String, Any])
  
  // 事件处理器工厂
  def createEventHandler(handlerName: String): Event => Unit = {
    var eventCount = 0
    
    (event: Event) => {
      eventCount += 1
      println(s"[$handlerName] 处理第 $eventCount 个事件: ${event.name}")
      event.data.foreach { case (key, value) =>
        println(s"  $key: $value")
      }
    }
  }
  
  // 条件事件处理器
  def createConditionalHandler(condition: Event => Boolean, action: Event => Unit): Event => Unit = {
    (event: Event) => {
      if (condition(event)) {
        action(event)
      }
    }
  }
  
  def main(args: Array[String]): Unit = {
    val handler1 = createEventHandler("Handler1")
    val handler2 = createEventHandler("Handler2")
    
    val events = List(
      Event("UserLogin", Map("userId" -> 123, "timestamp" -> System.currentTimeMillis())),
      Event("UserLogout", Map("userId" -> 123, "duration" -> 3600)),
      Event("DataUpdate", Map("table" -> "users", "records" -> 5))
    )
    
    // 处理事件
    events.foreach(handler1)
    
    println("\n--- 条件处理器 ---")
    
    // 只处理用户相关事件
    val userEventHandler = createConditionalHandler(
      _.name.startsWith("User"),
      event => println(s"用户事件: ${event.name}")
    )
    
    events.foreach(userEventHandler)
  }
}

配置和工厂模式

scala

object ConfigurationFactory {
  case class DatabaseConfig(host: String, port: Int, database: String)
  case class Connection(config: DatabaseConfig) {
    def query(sql: String): String = s"Executing '$sql' on ${config.host}:${config.port}/${config.database}"
  }
  
  // 配置工厂
  def createConnectionFactory(config: DatabaseConfig): () => Connection = {
    () => Connection(config)
  }
  
  // 带有连接池的工厂
  def createPooledConnectionFactory(config: DatabaseConfig, maxConnections: Int): () => Connection = {
    var connectionCount = 0
    
    () => {
      if (connectionCount < maxConnections) {
        connectionCount += 1
        println(s"创建新连接 (${connectionCount}/$maxConnections)")
        Connection(config)
      } else {
        println("连接池已满，重用现有连接")
        Connection(config)
      }
    }
  }
  
  // 带有重试机制的操作
  def createRetryableOperation[T](maxRetries: Int)(operation: () => T): () => Option[T] = {
    var attempts = 0
    
    () => {
      attempts += 1
      try {
        Some(operation())
      } catch {
        case _: Exception if attempts < maxRetries =>
          println(s"操作失败，重试 $attempts/$maxRetries")
          None
        case e: Exception =>
          println(s"操作最终失败: ${e.getMessage}")
          None
      }
    }
  }
  
  def main(args: Array[String]): Unit = {
    val config = DatabaseConfig("localhost", 5432, "myapp")
    
    // 简单工厂
    val connectionFactory = createConnectionFactory(config)
    val conn1 = connectionFactory()
    println(conn1.query("SELECT * FROM users"))
    
    // 连接池工厂
    val pooledFactory = createPooledConnectionFactory(config, 2)
    val conn2 = pooledFactory()
    val conn3 = pooledFactory()
    val conn4 = pooledFactory()  // 应该重用连接
    
    // 重试操作
    val riskyOperation = () => {
      if (scala.util.Random.nextBoolean()) {
        "操作成功"
      } else {
        throw new RuntimeException("随机失败")
      }
    }
    
    val retryableOp = createRetryableOperation(3)(riskyOperation)
    val result = retryableOp()
    println(s"操作结果: $result")
  }
}

闭包的注意事项

内存泄漏风险

scala

object MemoryLeakExample {
  // 可能导致内存泄漏的闭包
  def createLeakyClosures(): List[() => Int] = {
    val largeData = (1 to 1000000).toList  // 大量数据
    
    // 这些闭包都持有对 largeData 的引用
    (1 to 10).map { i =>
      () => largeData(i)  // 只使用了一个元素，但持有整个列表的引用
    }.toList
  }
  
  // 避免内存泄漏的方法
  def createEfficientClosures(): List[() => Int] = {
    val largeData = (1 to 1000000).toList
    
    // 只捕获需要的数据
    (1 to 10).map { i =>
      val value = largeData(i)  // 提取需要的值
      () => value  // 闭包只持有这个值的引用
    }.toList
  }
  
  def main(args: Array[String]): Unit = {
    println("创建高效的闭包...")
    val efficientClosures = createEfficientClosures()
    println(s"第一个闭包的结果: ${efficientClosures.head()}")
  }
}

变量捕获的时机

scala

object VariableCaptureTime {
  def main(args: Array[String]): Unit = {
    // 变量捕获的时机很重要
    var functions = List[() => Int]()
    
    // 错误的方式 - 所有闭包都捕获同一个变量
    for (i <- 1 to 5) {
      var x = i
      functions = (() => x) :: functions
    }
    
    println("错误的捕获方式:")
    functions.reverse.foreach(f => print(s"${f()} "))
    println()
    
    // 正确的方式 - 每个闭包捕获不同的值
    functions = List[() => Int]()
    for (i <- 1 to 5) {
      val x = i  // 使用 val 而不是 var
      functions = (() => x) :: functions
    }
    
    println("正确的捕获方式:")
    functions.reverse.foreach(f => print(s"${f()} "))
    println()
    
    // 使用函数式方法更安全
    val functionalApproach = (1 to 5).map(i => () => i).toList
    println("函数式方法:")
    functionalApproach.foreach(f => print(s"${f()} "))
    println()
  }
}

最佳实践

最小化捕获：只捕获闭包真正需要的变量
使用不可变变量：优先使用 val 而不是 var
避免捕获大对象：如果只需要对象的一部分，先提取出来
注意变量的生命周期：确保被捕获的变量在闭包使用期间有效
使用函数式方法：利用 map、filter 等高阶函数而不是手动创建闭包

闭包是 Scala 函数式编程的核心特性之一，正确理解和使用闭包对于编写高质量的 Scala 代码至关重要。

Scala 闭包 ​

什么是闭包 ​

基本闭包示例 ​

闭包 vs 普通函数 ​

闭包的创建和使用 ​

返回闭包的函数 ​

闭包作为参数 ​

闭包的高级用法 ​

柯里化和闭包 ​

闭包和集合操作 ​

闭包和状态管理 ​

闭包的实际应用 ​

事件处理 ​

配置和工厂模式 ​

闭包的注意事项 ​

内存泄漏风险 ​

变量捕获的时机 ​

最佳实践 ​

Scala 闭包

什么是闭包

基本闭包示例

闭包 vs 普通函数

闭包的创建和使用

返回闭包的函数

闭包作为参数

闭包的高级用法

柯里化和闭包

闭包和集合操作

闭包和状态管理

闭包的实际应用

事件处理

配置和工厂模式

闭包的注意事项

内存泄漏风险

变量捕获的时机

最佳实践