Closures
Zustand erfassen
Closures ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was ist eine Closure?
Eine Closure ist eine Funktion, die Variablen aus dem umgebenden Gültigkeitsbereich erfasst, in dem sie definiert wurde. Sie „schließt“ diese Variablen ein und behält den Zugriff darauf, auch nachdem dieser Gültigkeitsbereich bereits verlassen wurde.
object Main {
def main(args: Array[String]): Unit = {
val factor = 3
val multiply = (x: Int) => x * factor
println(multiply(5))
}
}Eine freie Variable erfassen
In x => x * factor ist x ein Parameter, während factor eine freie Variable aus dem umschließenden Gültigkeitsbereich ist. Die Funktion enthält eine Referenz auf diese Variable.
object Main {
def main(args: Array[String]): Unit = {
val greeting = "Hello"
val greet = (name: String) => s"$greeting, $name!"
println(greet("Ann"))
println(greet("Bob"))
}
}Closures bestehen über ihren Gültigkeitsbereich hinaus
Wenn eine Funktion eine Closure zurückgibt, bleiben die erfassten Variablen so lange erhalten wie die Closure selbst – auch wenn die definierende Funktion bereits beendet wurde.
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))
}
}Jede Closure hat eigene erfasste Variablen
Wenn Sie eine Funktionsfabrik zweimal aufrufen, entstehen zwei unabhängige Closures, die sich jeweils ihren eigenen erfassten Wert merken.
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"))
}
}Veränderlichen Zustand erfassen
Eine Closure kann eine var erfassen und sie sowohl lesen als auch aktualisieren. Dadurch kann eine Closure zwischen Aufrufen einen Zustand beibehalten, beispielsweise für einen Zähler.
object Main {
def main(args: Array[String]): Unit = {
var count = 0
val increment = () => { count += 1; count }
println(increment())
println(increment())
println(increment())
}
}Eine Zählerfabrik
Verbinden Sie die Konzepte: Eine Funktion, die eine Closure zurückgibt, welche ihre eigene private var erfasst, liefert Ihnen einen gekapselten, unabhängigen Zähler.
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())
}
}Closures erfassen Referenzen, keine Kopien
Eine Closure erfasst die Variable, nicht eine Momentaufnahme. Wenn sich die erfasste var nach dem Erstellen der Closure ändert, sieht die Closure den neuen Wert.
object Main {
def main(args: Array[String]): Unit = {
var msg = "first"
val show = () => println(msg)
show()
msg = "second"
show()
}
}Erfassen Sie bevorzugt val
Das Erfassen eines unveränderlichen val verhindert Überraschungen: Der erfasste Wert ändert sich nie, sodass sich die Closure vorhersehbar verhält. Verwenden Sie in funktionalem Code bevorzugt erfasste val-Werte.
object Main {
def main(args: Array[String]): Unit = {
val taxRate = 0.2
val withTax = (price: Double) => price * (1 + taxRate)
println(withTax(100))
}
}Closures mit Collection-Methoden
An map, filter usw. übergebene Lambdas sind Closures, sobald sie auf Variablen außerhalb ihres eigenen Gültigkeitsbereichs verweisen. Das ist in alltäglichem Scala-Code äußerst häufig.
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)
}
}Eine Falle beim Erfassen in Schleifen
In Scala ist die Variable einer for-Schleife bei jeder Iteration eine neue Bindung. Daher erfassen Closures jeweils unterschiedliche Werte. Das verhindert einen klassischen Fehler, der in manchen anderen Sprachen auftritt.
object Main {
def main(args: Array[String]): Unit = {
val fns = for (i <- 1 to 3) yield () => i
println(fns.map(f => f()))
}
}Closures kapseln Verhalten und Daten
Eine Closure bündelt Verhalten (den Funktionskörper) mit Daten (den erfassten Variablen). Das ist eine leichtgewichtige Alternative zu einem kleinen Objekt mit einer Methode.
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))
}
}Kurzer Test
Was erfasst eine Closure aus ihrem umgebenden Gültigkeitsbereich?
Zusammenfassung
Sie haben Closures kennengelernt:
- Eine Closure erfasst freie Variablen aus ihrem umschließenden Gültigkeitsbereich
- Erfasste Variablen bestehen über die definierende Funktion hinaus
- Jede Closure-Instanz besitzt ihren eigenen erfassten Zustand
- Closures erfassen Referenzen, daher können sich veränderliche erfasste Variablen ändern
- Lambdas für
map/filtersind alltägliche Closures
Häufig gestellte Fragen
Ist die Lektion „Closures“ kostenlos?
Ja — der vollständige Text von „Closures“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Closures“?
Zustand erfassen Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Closures“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.