Scala for Backend Engineering & Functional Programming · Pelajaran

map dan flatMap pada Option

Komposisikan dengan aman.

map dan flatMap pada Option adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 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.

Mengubah Option

Sering kali Anda memiliki sebuah Option dan ingin mengubah nilainya jika nilai tersebut ada, sementara membiarkan None tetap apa adanya.

Metode map melakukan tepat hal itu tanpa perlu membuka bungkusnya secara manual.

Menggunakan map

map menerapkan fungsi pada nilai di dalam Some dan mengembalikan Some baru. Pada None, metode ini tidak melakukan apa-apa dan mengembalikan None.

object Main {
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(10)
    val doubled = n.map(x => x * 2)
    println(doubled)
  }
}

map pada None

Saat Option bernilai None, map melewati fungsi sepenuhnya dan tetap menghasilkan None.

Inilah sifat keamanan utamanya: transformasi tidak melakukan apa-apa saat nilai tidak ada.

object Main {
  def main(args: Array[String]): Unit = {
    val empty: Option[Int] = None
    val result = empty.map(x => x * 2)
    println(result)
  }
}

Mengubah Tipe

map dapat mengubah nilai menjadi tipe yang berbeda, seperti pada koleksi. Di sini, Option[Int] menjadi Option[String].

object Main {
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(7)
    val label = n.map(x => s"value=$x")
    println(label)
  }
}

Masalah Perulangan Bersarang

Bagaimana jika fungsi Anda sendiri mengembalikan sebuah Option? Menggunakan map akan menghasilkan Option[Option[A]] bersarang, yang kurang praktis.

Di sinilah flatMap berperan.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(8)
    val nested = n.map(half)
    println(nested)
  }
}

Menggunakan flatMap

flatMap menerapkan fungsi yang mengembalikan sebuah Option dan meratakan hasilnya menjadi satu Option.

Bandingkan keluaran ini dengan versi bersarang dari adegan sebelumnya.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(8)
    val flat = n.flatMap(half)
    println(flat)
  }
}

Merangkai flatMap

Karena setiap langkah mengembalikan sebuah Option, Anda dapat merangkai beberapa pemanggilan flatMap. Jika salah satu langkah menghasilkan None, seluruh rangkaian menjadi None.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val result = Some(16).flatMap(half).flatMap(half)
    println(result)
  }
}

Berhenti Singkat pada None

Jika langkah di tengah mengembalikan None, langkah-langkah berikutnya dilewati dan hasil akhirnya adalah None.

Penghentian otomatis ini menghilangkan pemeriksaan null secara manual.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val result = Some(8).flatMap(half).flatMap(half)
    println(result)
  }
}

Menggabungkan map dan flatMap

Gunakan flatMap untuk langkah-langkah yang mengembalikan Option, dan map untuk transformasi biasa yang terakhir.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = Some("21").flatMap(parse).map(_ * 2)
    println(result)
  }
}

Mengapa map dan flatMap?

Metode-metode ini memungkinkan Anda untuk:

Mentransformasi nilai tanpa membukanya
Secara otomatis melewati pekerjaan pada None
Merangkai operasi yang mungkin gagal
Menghindari Option[Option[A]] bertingkat dengan flatten

Menyatukan Semuanya

Rangkaian yang realistis: mencari kunci, menguraikannya, lalu mentransformasinya dengan aman.

object Main {
  val config = Map("port" -> "8080")
  def main(args: Array[String]): Unit = {
    val port = config.get("port").flatMap(_.toIntOption).map(_ + 1)
    println(port)
    val missing = config.get("host").flatMap(_.toIntOption)
    println(missing)
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang map dan flatMap.

Ringkasan

Anda telah mempelajari cara menyusun Option:

map mentransformasi nilai di dalam Some, sementara None tetap dibiarkan
flatMap menerapkan fungsi yang mengembalikan Option dan meratakan hasilnya
Perangkaian berhenti lebih awal menjadi None jika salah satu langkahnya adalah None
Gunakan flatMap untuk langkah yang mengembalikan Option, dan map untuk langkah biasa

Pertanyaan yang Sering Diajukan

Apakah pelajaran “map dan flatMap pada Option” gratis?

Ya — teks lengkap “map dan flatMap pada Option” 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 “map dan flatMap pada Option”?

Komposisikan dengan aman. 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 2 dari 4.

Berapa lama pelajaran “map dan flatMap pada Option” 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

← Kembali ke Scala for Backend Engineering & Functional Programming