Menggunakan Option dan Future
Perangkaian monadik.
Menggunakan Option dan Future 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.
Melampaui koleksi
Ekspresi for tidak terbatas pada daftar. Jenis apa pun yang menyediakan map dan flatMap dapat digunakan, termasuk Option, Either, Try, dan Future. Ini disebut perantaian monadik.
object Main {
def main(args: Array[String]): Unit = {
val sum = for {
a <- Some(10)
b <- Some(20)
} yield a + b
println(sum)
}
}Option berhenti lebih awal pada None
Dengan Option, ekspresi tersebut menghasilkan nilai hanya jika setiap pembangkit berupa Some. Jika salah satunya berupa None, seluruh hasil menjadi None dan langkah berikutnya dilewati.
object Main {
def main(args: Array[String]): Unit = {
val ok = for {
a <- Some(2)
b <- Some(3)
} yield a * b
val missing = for {
a <- Some(2)
b <- None: Option[Int]
} yield a * b
println(ok)
println(missing)
}
}Merangkai pencarian opsional
Pola yang umum adalah mencari kunci dalam Map, ketika setiap pencarian mengembalikan Option. Ekspresi for menghasilkan nilai hanya jika semua pencarian berhasil.
object Main {
def main(args: Array[String]): Unit = {
val prices = Map("apple" -> 3, "bread" -> 5)
val total = for {
a <- prices.get("apple")
b <- prices.get("bread")
} yield a + b
println(total)
val missing = for {
a <- prices.get("apple")
c <- prices.get("milk")
} yield a + c
println(missing)
}
}Mengapa ini lebih baik daripada if-else bersarang
Tanpa ekspresi for, Anda harus membuat pencocokan pola atau pemeriksaan null bersarang. Bentuk monadik meratakan piramida tersebut menjadi rangkaian linear yang rapi.
object Main {
def parse(s: String): Option[Int] = s.toIntOption
def main(args: Array[String]): Unit = {
val result = for {
x <- parse("40")
y <- parse("2")
} yield x + y
println(result)
}
}Penjaga juga berfungsi dengan Option
Penjaga di dalam ekspresi Option mengubah suatu nilai menjadi None ketika kondisi gagal, sehingga berfungsi sebagai validasi sebaris.
object Main {
def main(args: Array[String]): Unit = {
def validate(age: Int): Option[Int] =
for {
a <- Some(age)
if a >= 18
} yield a
println(validate(25))
println(validate(15))
}
}Memperkenalkan Future
Future merepresentasikan nilai yang akan tersedia nanti. Seperti Option, Future memiliki map dan flatMap, sehingga ekspresi for dapat mengurutkan langkah-langkah asinkron.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._
object Main {
def main(args: Array[String]): Unit = {
val f = for {
a <- Future(10)
b <- Future(20)
} yield a + b
println(Await.result(f, 2.seconds))
}
}Future berjalan berurutan di sini
Ketika satu pembangkit bergantung pada pembangkit lain di dalam ekspresi for, future berjalan secara berurutan karena setiap flatMap menunggu hasil sebelumnya.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._
object Main {
def main(args: Array[String]): Unit = {
val f = for {
a <- Future(5)
b <- Future(a * 2)
} yield a + b
println(Await.result(f, 2.seconds))
}
}Menjalankan future secara paralel
Untuk menjalankan future secara paralel, mulai semuanya sebelum ekspresi for, lalu gabungkan. Pekerjaan yang tidak saling bergantung akan berjalan tumpang tindih, bukan saling menunggu.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._
object Main {
def main(args: Array[String]): Unit = {
val fa = Future(100)
val fb = Future(200)
val combined = for {
a <- fa
b <- fb
} yield a + b
println(Await.result(combined, 2.seconds))
}
}Either untuk kesalahan yang lebih informatif
Either[E, A] membawa nilai kesalahan ketika terjadi kegagalan. Dalam ekspresi for, Left pertama menghentikan proses lebih awal dan dikembalikan.
object Main {
def parse(s: String): Either[String, Int] =
s.toIntOption.toRight(s"not a number: $s")
def main(args: Array[String]): Unit = {
val good = for { a <- parse("3"); b <- parse("4") } yield a + b
val bad = for { a <- parse("3"); b <- parse("x") } yield a + b
println(good)
println(bad)
}
}Bentuk yang sama, banyak jenis
Perhatikan bahwa ekspresi tersebut terlihat identik baik Anda menggunakan Option, Either, Try, maupun Future. Yang berbeda hanyalah semantik kegagalannya. Keseragaman inilah kekuatan perantaian monadik.
import scala.util.Try
object Main {
def main(args: Array[String]): Unit = {
val result = for {
a <- Try("21".toInt)
b <- Try("2".toInt)
} yield a * b
println(result)
}
}Pencampuran jenis tidak diizinkan
Semua pembangkit dalam satu ekspresi harus menggunakan monad yang sama. Anda tidak dapat langsung mencampur pembangkit Option dengan pembangkit Future; konversikan salah satunya terlebih dahulu, misalnya dengan Future.fromTry, atau bungkus Option tersebut.
object Main {
def main(args: Array[String]): Unit = {
// Convert the Option to keep types consistent
val maybe: Option[Int] = Some(7)
val result = for {
a <- maybe
b <- maybe.map(_ + 1)
} yield a + b
println(result)
}
}Pemeriksaan Cepat
Dalam ekspresi for Option, apa yang terjadi jika salah satu pembangkit menghasilkan None?
Ringkasan
Anda telah mempelajari perantaian monadik dengan ekspresi for:
- Berfungsi pada jenis apa pun yang memiliki
mapdanflatMap Optionberhenti lebih awal padaNoneEitherdanTryberhenti lebih awal saat gagal sambil membawa informasi kesalahanFuturemengurutkan langkah asinkron; mulai lebih awal untuk menjalankannya secara paralel- Semua pembangkit harus menggunakan jenis monad yang sama
Belajar Scala dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 39
- Pelajaran
- 143
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Menggunakan Option dan Future” gratis?
Ya — teks lengkap “Menggunakan Option dan Future” 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 “Menggunakan Option dan Future”?
Perangkaian monadik. 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 “Menggunakan Option dan Future” 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
- Desugaring for
- Penyaringan dengan if
- Beberapa Generator
- Menggunakan Option dan Future