0Pricing
Scala for Backend Engineering & Functional Programming · Lektion

Mehrere Generatoren

Verschachtelte Iteration

Mehrere Generatoren ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Verschachtelte Iteration, flach geschrieben

Eine For-Comprehension kann mehrere Generatoren enthalten. Jeder davon ist eine <--Zeile, die über eine Collection iteriert. Zusammen erzeugen sie jede mögliche Kombination – eine Art verschachtelte Schleife in flacher Schreibweise.

object Main {
  def main(args: Array[String]): Unit = {
    val pairs = for {
      x <- List(1, 2)
      y <- List('a', 'b')
    } yield (x, y)
    println(pairs)
  }
}

Es handelt sich um ein kartesisches Produkt

Zwei Generatoren mit den Größen m und n erzeugen m × n Ergebnisse, also das vollständige kartesische Produkt. Der erste Generator ist die äußere Schleife, der zweite die innere.

object Main {
  def main(args: Array[String]): Unit = {
    val grid = for {
      row <- 1 to 3
      col <- 1 to 3
    } yield s"r$row-c$col"
    println(grid.mkString(", "))
  }
}

Der innere Generator kann vom äußeren abhängen

Ein späterer Generator kann Werte verwenden, die von früheren Generatoren gebunden wurden. Mit einem einfachen kartesischen Produkt wäre das nicht möglich. Das ist ein Grund für die große Flexibilität von For-Comprehensions.

object Main {
  def main(args: Array[String]): Unit = {
    val upperTriangle = for {
      i <- 1 to 4
      j <- i to 4
    } yield (i, j)
    println(upperTriangle)
  }
}

Drei oder mehr Generatoren

Sie können beliebig viele Generatoren aneinanderreihen. Mit drei Generatoren erhalten Sie eine dreifach verschachtelte Schleife, die Tupel oder berechnete Werte erzeugt.

object Main {
  def main(args: Array[String]): Unit = {
    val triples = for {
      a <- 1 to 2
      b <- 1 to 2
      c <- 1 to 2
    } yield (a, b, c)
    println(triples.size + " combinations")
    triples.foreach(println)
  }
}

Das klassische pythagoreische Beispiel

Eine bekannte Anwendung ist das Finden pythagoreischer Tripel. Wir iterieren über drei Zahlen und behalten nur diejenigen, für die a*a + b*b == c*c gilt, indem wir mehrere Generatoren mit einem Guard kombinieren.

object Main {
  def main(args: Array[String]): Unit = {
    val triples = for {
      a <- 1 to 20
      b <- a to 20
      c <- b to 20
      if a * a + b * b == c * c
    } yield (a, b, c)
    triples.foreach(println)
  }
}

Auflösung in einfachere Operationen

Mehrere Generatoren werden zu verschachtelten flatMap-Aufrufen mit einem abschließenden map:

  • xs.flatMap(x => ys.flatMap(y => zs.map(z => ...)))

Jeder weitere Generator fügt eine weitere Verschachtelungsebene hinzu.

object Main {
  def main(args: Array[String]): Unit = {
    val sugar = for {
      x <- List(1, 2)
      y <- List(3, 4)
    } yield x * y
    val desugared = List(1, 2).flatMap(x => List(3, 4).map(y => x * y))
    println(sugar == desugared)
  }
}

Generatoren und Guards kombinieren

Sie können Generatoren und Guards frei miteinander abwechseln. Ein Guard zwischen zwei Generatoren schneidet äußere Werte ab, bevor die innere Schleife überhaupt ausgeführt wird.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- 1 to 5
      if x % 2 == 1
      y <- 1 to 5
      if y > x
    } yield (x, y)
    println(result)
  }
}

Verschachtelte Collections abflachen

Wenn Sie eine Collection aus Collections haben, können Sie sie mit zwei Generatoren auf natürliche Weise abflachen: Der erste iteriert über die äußere Collection, der zweite über jede innere.

object Main {
  def main(args: Array[String]): Unit = {
    val matrix = List(List(1, 2), List(3, 4), List(5, 6))
    val flat = for {
      row <- matrix
      value <- row
    } yield value
    println(flat)
  }
}

Ein Stringraster erstellen

Mehrere Generatoren eignen sich hervorragend zum Erzeugen strukturierter Ausgaben, etwa von Koordinaten oder einer Multiplikationstabelle.

object Main {
  def main(args: Array[String]): Unit = {
    val table = for {
      i <- 1 to 3
      j <- 1 to 3
    } yield s"$i*$j=${i * j}"
    println(table.grouped(3).map(_.mkString("  ")).mkString("\n"))
  }
}

Collections unterschiedlicher Größe kombinieren

Generatoren müssen nicht gleich lang sein. Es wird jede Kombination aus jeweils einem Element jeder Collection erzeugt.

object Main {
  def main(args: Array[String]): Unit = {
    val sizes = List("S", "M", "L")
    val colors = List("red", "blue")
    val products = for {
      s <- sizes
      c <- colors
    } yield s"$c-$s"
    println(products)
  }
}

Die Reihenfolge beeinflusst die Ausgabefolge

Wenn Sie die Reihenfolge der Generatoren vertauschen, bleibt dieselbe Menge an Kombinationen erhalten, aber ihre Reihenfolge ändert sich, weil der letzte Generator am schnellsten variiert.

object Main {
  def main(args: Array[String]): Unit = {
    val ab = for { x <- List(1, 2); y <- List(9, 8) } yield (x, y)
    val ba = for { y <- List(9, 8); x <- List(1, 2) } yield (x, y)
    println(ab)
    println(ba)
  }
}

Schnelltest

Wie viele Tupel erzeugt for { x <- List(1,2,3); y <- List('a','b') } yield (x, y)?

Zusammenfassung

Sie haben mehrere Generatoren kennengelernt:

  • Jede <--Zeile fügt eine Ebene verschachtelter Iteration hinzu
  • Zusammen erzeugen sie das kartesische Produkt
  • Innere Generatoren können von gebundenen Werten äußerer Generatoren abhängen
  • Sie werden in verschachtelte flatMap-Aufrufe und ein abschließendes map übersetzt
  • Die Reihenfolge der Generatoren ändert die Reihenfolge der Ergebnisse

Häufig gestellte Fragen

Ist die Lektion „Mehrere Generatoren“ kostenlos?

Ja — der vollständige Text von „Mehrere Generatoren“ 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 „Mehrere Generatoren“?

Verschachtelte Iteration 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 3 von 4.

Wie lange dauert die Lektion „Mehrere Generatoren“?

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.

Alle Lektionen in diesem Kurs

  1. for desugaren
  2. Mit if filtern
  3. Mehrere Generatoren
  4. Verwendung mit Option und Future
← Zurück zu Scala for Backend Engineering & Functional Programming