0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Beberapa Generator

Iterasi bertingkat.

Beberapa Generator adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Iterasi bersarang menjadi datar

Sebuah ekspresi for dapat memiliki beberapa pembangkit. Masing-masing adalah baris <- yang melakukan iterasi pada suatu koleksi. Bersama-sama, semuanya menghasilkan setiap kombinasi, seperti perulangan bersarang yang ditulis secara datar.

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

Ini adalah hasil kali Kartesius

Dua pembangkit berukuran m dan n menghasilkan m × n hasil, yaitu hasil kali Kartesius lengkap. Pembangkit pertama adalah perulangan luar, sedangkan pembangkit kedua adalah perulangan dalam.

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(", "))
  }
}

Pembangkit dalam dapat bergantung pada pembangkit luar

Pembangkit berikutnya dapat menggunakan nilai yang diikat oleh pembangkit sebelumnya. Hal ini tidak mungkin dilakukan dengan hasil kali Kartesius biasa dan merupakan salah satu alasan ekspresi for sangat fleksibel.

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

Tiga pembangkit atau lebih

Anda dapat menyusun sebanyak mungkin pembangkit yang diperlukan. Dengan tiga pembangkit, Anda mendapatkan perulangan bersarang tiga tingkat yang menghasilkan tuple atau nilai terhitung.

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)
  }
}

Contoh Pythagoras klasik

Salah satu penggunaan yang terkenal adalah mencari tripel Pythagoras. Kita melakukan iterasi pada tiga angka dan hanya mempertahankan angka yang memenuhi a*a + b*b == c*c, dengan menggabungkan beberapa pembangkit dan penjaga.

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)
  }
}

Cara penyederhanaan sintaksnya

Beberapa pembangkit menjadi pemanggilan flatMap bersarang dengan map terakhir:

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

Setiap pembangkit tambahan menambahkan satu tingkat bersarang.

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)
  }
}

Memadukan pembangkit dan penjaga

Anda dapat menyisipkan pembangkit dan penjaga secara bebas. Penjaga yang ditempatkan di antara dua pembangkit akan memangkas nilai luar sebelum perulangan dalam bahkan dijalankan.

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)
  }
}

Meratakan koleksi bersarang

Jika Anda memiliki koleksi yang berisi koleksi, dua pembangkit dapat meratakannya secara alami: pembangkit pertama melakukan iterasi pada koleksi luar, sedangkan pembangkit kedua melakukan iterasi pada setiap koleksi dalam.

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)
  }
}

Membangun kisi string

Beberapa pembangkit sangat berguna untuk menghasilkan keluaran terstruktur, seperti koordinat atau tabel perkalian.

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"))
  }
}

Menggabungkan koleksi dengan ukuran berbeda

Pembangkit tidak harus memiliki panjang yang sama. Setiap kombinasi yang terdiri dari satu elemen dari masing-masing pembangkit akan dihasilkan.

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)
  }
}

Urutan memengaruhi rangkaian keluaran

Menukar urutan pembangkit mempertahankan himpunan kombinasi yang sama, tetapi mengubah urutannya, karena pembangkit terakhir berubah paling cepat.

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)
  }
}

Pemeriksaan Cepat

Berapa banyak tuple yang dihasilkan oleh for { x <- List(1,2,3); y <- List('a','b') } yield (x, y)?

Ringkasan

Anda telah mempelajari beberapa pembangkit:

  • Setiap baris <- menambahkan satu tingkat iterasi bersarang
  • Bersama-sama, semuanya menghasilkan hasil kali Kartesius
  • Pembangkit dalam dapat bergantung pada nilai terikat dari pembangkit luar
  • Semuanya disederhanakan menjadi flatMap bersarang + map terakhir
  • Urutan pembangkit mengubah urutan hasil

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Beberapa Generator” gratis?

Ya — teks lengkap “Beberapa Generator” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Beberapa Generator”?

Iterasi bertingkat. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Beberapa Generator” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Desugaring for
  2. Penyaringan dengan if
  3. Beberapa Generator
  4. Menggunakan Option dan Future
← Kembali ke Scala for Backend Engineering & Functional Programming