Scala Closures

In Scala ist eine Closure eine Funktion, die freie Variablen aus ihrer definierenden Umgebung erfassen und einschließen kann.

Eine Closure ist eine Funktion, deren Rückgabewert von einer oder mehreren außerhalb der Funktion deklarierten Variablen abhängt.

Eine Closure kann auf Variablen außerhalb der Funktion zugreifen und sie innerhalb der Funktion verwenden. Selbst wenn der Gültigkeitsbereich der Variablen über ihre definierende Umgebung hinausgegangen ist, kann die Closure weiterhin auf diese Variablen zugreifen.

Der Schlüssel zu einer Closure ist, dass sie Variablen außerhalb der Funktion "einschließen" kann, wodurch diese Variablen innerhalb der Funktion weiterhin verfügbar bleiben.

Wie die folgende anonyme Funktion:

val multiplier = (i:Int) => i * 10  

Innerhalb des Funktionskörpers gibt es eine Variable i, die ein Parameter der Funktion ist. Wie im folgenden Codeabschnitt:

val multiplier = (i:Int) => i * factor

In multiplier gibt es zwei Variablen: i und factor. Eine davon, i, ist ein formaler Parameter der Funktion; wenn die Funktion multiplier aufgerufen wird, wird i ein neuer Wert zugewiesen. factor ist jedoch kein formaler Parameter, sondern eine freie Variable. Betrachten Sie den folgenden Code:

var factor = 3  
val multiplier = (i:Int) => i * factor  

Hier führen wir eine freie Variable factor ein, die außerhalb der Funktion definiert ist.

Die so definierte Funktionsvariable multiplier wird zu einer "Closure", weil sie auf eine außerhalb der Funktion definierte Variable verweist. Der Prozess der Definition dieser Funktion erfasst diese freie Variable, um eine geschlossene Funktion zu bilden.

Vollständiges Beispiel

Beispiel

object Test {  
   def main(args: Array[String]) {  
      println( "muliplier(1) value = " + multiplier(1) )  
      println( "muliplier(2) value = " + multiplier(2) )  
   }  
   var factor = 3  
   val multiplier = (i:Int) => i * factor  
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

$ scalac Test.scala  
$  scala Test  
muliplier(1) value = 3  
muliplier(2) value = 6  

Im folgenden Beispiel erfasst die Closure-Funktion die externe Variable externalVar. Wenn sich der Wert von externalVar ändert, ändert sich das Berechnungsergebnis innerhalb der Closure entsprechend.

Beispiel

object ClosureExample1 {
  def main(args: Array[String]): Unit = {
    var externalVar = 10

    val closure = (x: Int) => x + externalVar

    println(closure(5))  // Ausgabe 15

    externalVar = 20

    println(closure(5))  // Ausgabe 25
  }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

15
25

Closures als Rückgabewerte

Im Folgenden gibt die Funktion makeAdder eine Closure zurück. Verschiedene Closures erfassen unterschiedliche Werte von adder.

Beispiel

object ClosureExample2 {
  def main(args: Array[String]): Unit = {
    def makeAdder(adder: Int): Int => Int = {
      (x: Int) => x + adder
    }

    val addFive = makeAdder(5)
    val addTen = makeAdder(10)

    println(addFive(3))  // Ausgabe 8
    println(addTen(3))   // Ausgabe 13
  }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

8
13

Typen von Variablen, die von Closures erfasst werden

Closures können Variablen unterschiedlicher Typen erfassen, einschließlich Werttypen und Referenztypen.

Im folgenden Beispiel erfasst die Closure addMessage die Variable messages und kann sie ändern.

Beispiel

object ClosureExample3 {
  def main(args: Array[String]): Unit = {
    var messages = List("Hello", "World")

    val addMessage = (msg: String) => messages = messages :+ msg

    addMessage("Scala")
    println(messages)  // Ausgabe List(Hello, World, Scala)
  }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

List(Hello, World, Scala)

Closures und funktionale Programmierung

Closures sind ein wichtiges Konzept in der funktionalen Programmierung und werden häufig in Techniken wie Funktionen höherer Ordnung und Currying verwendet.

Im folgenden Beispiel akzeptiert die Funktion highOrderFunction eine Funktion als Parameter. Die übergebene Closure erfasst die externe Variable externalVar.

Beispiel

object ClosureExample4 {
  def main(args: Array[String]): Unit = {
    def highOrderFunction(f: Int => Int, x: Int): Int = f(x)

    val externalVar = 5
    val closure = (x: Int) => x + externalVar

    println(highOrderFunction(closure, 10))  // Ausgabe 15
  }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

15
Andere Erweiterungen