0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Menyusun Either

map dan flatMap.

Menyusun Either 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.

Menggabungkan Komputasi

Program nyata merangkai beberapa tahap yang dapat gagal: mengurai, memvalidasi, mencari, lalu menghitung. Either memungkinkan Anda menggabungkan tahap-tahap ini sehingga kegagalan pertama langsung menghentikan seluruh rangkaian.

Alat yang digunakan adalah map, flatMap, dan pemahaman for.

flatMap Mengurutkan Either

flatMap menerapkan fungsi yang juga mengembalikan Either. Jika penerimanya berupa Left, fungsi tersebut tidak pernah dipanggil dan Left diteruskan.

object Main {
  def positive(n: Int): Either[String, Int] =
    if (n > 0) Right(n) else Left("not positive")

  def main(args: Array[String]): Unit = {
    val r = Right(5).flatMap(positive)
    val l = Right(-1).flatMap(positive)
    println(r)
    println(l)
  }
}

Penghentian Langsung

Ketika Anda merangkai beberapa pemanggilan flatMap, Left pertama menghentikan semuanya. Tahap-tahap berikutnya dilewati, dan kesalahan tersebut menjadi hasil akhir.

object Main {
  def step(label: String, n: Int): Either[String, Int] = {
    println(s"running $label")
    Right(n + 1)
  }

  def main(args: Array[String]): Unit = {
    val result = Left("early error").asInstanceOf[Either[String, Int]]
      .flatMap(n => step("A", n))
      .flatMap(n => step("B", n))
    println(result)
  }
}

Pemahaman for atas Either

Karena Either berpihak pada Right, Anda dapat menggunakannya dalam pemahaman for. Setiap <- membuka bungkus Right; Left apa pun akan menghentikan pemahaman dan menjadi hasilnya.

object Main {
  def parse(s: String): Either[String, Int] =
    s.toIntOption.toRight(s"bad: $s")

  def main(args: Array[String]): Unit = {
    val sum = for {
      a <- parse("3")
      b <- parse("4")
    } yield a + b
    println(sum)
  }
}

Pemahaman for yang Gagal

Jika salah satu tahap dalam pemahaman menghasilkan Left, seluruh ekspresi menjadi Left tersebut dan tahap-tahap berikutnya tidak dijalankan.

object Main {
  def parse(s: String): Either[String, Int] =
    s.toIntOption.toRight(s"bad: $s")

  def main(args: Array[String]): Unit = {
    val sum = for {
      a <- parse("3")
      b <- parse("oops")
      c <- parse("5")
    } yield a + b + c
    println(sum)
  }
}

Merangkai Validasi

Alur pemrosesan yang realistis: mengurai string, lalu memeriksa aturan bisnis, kemudian mengubah hasilnya. Setiap tahap mengembalikan Either.

object Main {
  def parse(s: String): Either[String, Int] = s.toIntOption.toRight("not a number")
  def checkRange(n: Int): Either[String, Int] =
    if (n >= 1 && n <= 100) Right(n) else Left("out of range")

  def process(s: String): Either[String, Int] =
    parse(s).flatMap(checkRange).map(_ * 10)

  def main(args: Array[String]): Unit = {
    println(process("7"))
    println(process("500"))
    println(process("x"))
  }
}

map dibandingkan flatMap

Gunakan map ketika fungsi Anda mengembalikan nilai biasa. Gunakan flatMap ketika fungsi tersebut mengembalikan Either lain, untuk menghindari Either[String, Either[String, Int]] bertingkat.

@main def run(): Unit = {
  val withMap: Either[String, Int] = Right(2).map(_ + 1)
  val nested: Either[String, Either[String, Int]] = Right(2).map(n => Right(n + 1))
  val flat: Either[String, Int] = Right(2).flatMap(n => Right(n + 1))
  println(withMap)
  println(nested)
  println(flat)
}

Menggabungkan Nilai yang Tidak Bergantung

Pemahaman for juga berfungsi ketika setiap tahap tidak bergantung pada tahap sebelumnya. Semua tahap harus berhasil agar yield akhir dijalankan.

object Main {
  def parse(s: String): Either[String, Int] = s.toIntOption.toRight(s"bad: $s")

  def main(args: Array[String]): Unit = {
    val combined = for {
      x <- parse("10")
      y <- parse("20")
      z <- parse("30")
    } yield List(x, y, z).sum
    println(combined)
  }
}

Transformasi Kesalahan Bergaya leftMap

Pustaka standar Either tidak memiliki leftMap, tetapi Anda dapat mengubah kesalahan dengan swap.map(...).swap atau dengan melakukan pemetaan di dalam fold. Dengan demikian, tipe kesalahan tetap konsisten di seluruh alur pemrosesan.

@main def run(): Unit = {
  val e: Either[String, Int] = Left("low-level error")
  val mapped = e.swap.map(msg => s"context: $msg").swap
  println(mapped)
}

Menggabungkan Semuanya

Alur pemrosesan kalkulator kecil yang mengurai dua angka lalu membaginya, dengan melaporkan setiap kegagalan sebagai kesalahan bertipe.

object Main {
  def parse(s: String): Either[String, Int] = s.toIntOption.toRight(s"bad number: $s")
  def divide(a: Int, b: Int): Either[String, Int] =
    if (b == 0) Left("division by zero") else Right(a / b)

  def calc(x: String, y: String): Either[String, Int] =
    for {
      a <- parse(x)
      b <- parse(y)
      r <- divide(a, b)
    } yield r

  def main(args: Array[String]): Unit = {
    println(calc("20", "4"))
    println(calc("20", "0"))
    println(calc("x", "4"))
  }
}

Mengapa Ini Penting

Menggabungkan Either memberi Anda pemrograman berorientasi jalur: jalur normal mengalir melalui Right, sedangkan kesalahan apa pun beralih ke jalur Left dan melewati bagian selanjutnya. Tanpa pengecualian, tanpa pemeriksaan null, hanya nilai.

Pemeriksaan singkat

Uji pemahaman Anda tentang penggabungan Either.

Ringkasan

Anda telah mempelajari cara menggabungkan Either:

  • flatMap mengurutkan tahap-tahap yang dapat gagal dan berhenti saat menemukan Left pertama.
  • Pemahaman for membuat alur pemrosesan bertahap lebih mudah dibaca.
  • Gunakan map untuk hasil biasa, dan flatMap untuk fungsi yang mengembalikan Either.
  • Ubah kesalahan dengan swap.map(...).swap.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menyusun Either” gratis?

Ya — teks lengkap “Menyusun Either” 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 “Menyusun Either”?

map dan flatMap. 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 “Menyusun Either” 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. Either untuk Error
  2. Try, Success, Failure
  3. Menyusun Either
  4. Mengonversi Antar-Tipe
← Kembali ke Scala for Backend Engineering & Functional Programming