0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Option dalam for-comprehension

Rangkai option.

Option dalam for-comprehension adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 4 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.

Merangkai Option dengan Rapi

Merangkai beberapa pemanggilan flatMap dan map dapat menyulitkan pembacaan. for-komprehensi Scala menawarkan sintaks yang lebih rapi untuk hal yang sama.

Ini adalah gula sintaksis yang ditulis ulang oleh kompilator menjadi pemanggilan flatMap dan map.

For-komprehensi Dasar

Di dalam for { ... } yield ..., setiap x <- option mengambil nilai jika tersedia. yield membentuk hasil akhir.

Jika setiap Option adalah Some, Anda mendapatkan Some yang berisi hasil tersebut.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Berhenti Lebih Awal pada None

Jika salah satu generator bernilai None, seluruh komprehensi menghasilkan None. Langkah-langkah yang tersisa dilewati.

Ini adalah penghentian lebih awal yang sama seperti yang disediakan flatMap, tetapi lebih mudah dibaca.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = None
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Cara Penulisannya Diubah

Kompilator menulis ulang for-komprehensi menjadi flatMap dan map. Kedua cuplikan ini setara.

Memahami hal ini membantu Anda memprediksi tipe hasilnya.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val viaFor = for { x <- a; y <- b } yield x + y
    val viaFlatMap = a.flatMap(x => b.map(y => x + y))
    println(viaFor)
    println(viaFlatMap)
  }
}

Menggunakan Nilai Sebelumnya

Generator berikutnya dapat merujuk pada nilai yang diikat sebelumnya. Dengan demikian, setiap langkah dapat bergantung pada langkah sebelumnya.

object Main {
  def main(args: Array[String]): Unit = {
    val base: Option[Int] = Some(10)
    val result = for {
      x <- base
      y <- Some(x * 2)
    } yield x + y
    println(result)
  }
}

Pengikatan Perantara

Anda dapat memperkenalkan nilai biasa di dalam komprehensi dengan = (tanpa panah). Ini berguna untuk perhitungan perantara.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(6)
    val result = for {
      x <- a
      doubled = x * 2
    } yield doubled + 1
    println(result)
  }
}

Penjaga dengan if

Sebuah komprehensi dapat menyertakan penyaring if. Jika kondisinya gagal, hasilnya menjadi None.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(8)
    val even = for {
      x <- a
      if x % 2 == 0
    } yield x
    println(even)
    val b: Option[Int] = Some(7)
    println(for { x <- b if x % 2 == 0 } yield x)
  }
}

Menggabungkan Pencarian

Penggunaan yang umum: mencari beberapa kunci dan menggabungkannya hanya jika semuanya tersedia.

object Main {
  val data = Map("a" -> 1, "b" -> 2)
  def main(args: Array[String]): Unit = {
    val combined = for {
      x <- data.get("a")
      y <- data.get("b")
    } yield x + y
    println(combined)
    val missing = for {
      x <- data.get("a")
      z <- data.get("c")
    } yield x + z
    println(missing)
  }
}

Mengapa for-komprehensi?

For-komprehensi memberikan Anda:

  • Urutan Option yang saling bergantung dan mudah dibaca
  • Penghentian lebih awal secara otomatis pada None
  • Kemampuan yang sama seperti flatMap/map, tetapi dalam bentuk yang lebih datar
  • Penyaringan dengan if dan pengikatan perantara dengan =

Mendapatkan Nilai

Komprehensi menghasilkan sebuah Option, jadi akhiri dengan getOrElse atau fold untuk mendapatkan nilai biasa.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val total = (for { x <- a; y <- b } yield x + y).getOrElse(0)
    println(total)
  }
}

Menyatukan Semuanya

Alur lengkap: uraikan dua input, periksa kondisi, gabungkan, lalu sediakan nilai bawaan.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- parse("10")
      y <- parse("5")
      if y != 0
    } yield x / y
    println(result.getOrElse(-1))
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang for-komprehensi pada Option.

Ringkasan

Anda telah mempelajari cara merangkai Option dengan for-komprehensi:

  • for { x <- a; y <- b } yield ... mengurutkan Option dengan cara yang mudah dibaca
  • Strukturnya diubah menjadi flatMap/map
  • Setiap None menghentikan seluruh hasil lebih awal menjadi None
  • Generator berikutnya dapat menggunakan nilai sebelumnya; = menambahkan pengikatan; if melakukan penyaringan
  • Akhiri dengan getOrElse atau fold untuk mendapatkan nilai biasa

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Option dalam for-comprehension” gratis?

Ya — teks lengkap “Option dalam for-comprehension” 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 “Option dalam for-comprehension”?

Rangkai option. 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 4 dari 4.

Berapa lama pelajaran “Option dalam for-comprehension” 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. Menghindari null
  2. map dan flatMap pada Option
  3. getOrElse dan fold
  4. Option dalam for-comprehension
← Kembali ke Scala for Backend Engineering & Functional Programming