0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Mengonversi Antar-Tipe

Option, Either, Try.

Mengonversi Antar-Tipe 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.

Tiga Model Kesalahan

Scala menyediakan tiga tipe yang saling melengkapi untuk ketiadaan dan kegagalan:

  • Option — ada atau tidak ada (tanpa alasan).
  • Either — berhasil atau kesalahan bertipe.
  • Try — berhasil atau pengecualian yang dilempar.

Dengan mengetahui cara mengonversi di antara ketiganya, Anda dapat menyesuaikan satu API dengan API lainnya.

Option ke Either

toRight mengonversi Option menjadi Either, dengan menyediakan kesalahan Left untuk kasus None. toLeft melakukan pemetaan sebaliknya.

@main def run(): Unit = {
  val some: Option[Int] = Some(5)
  val none: Option[Int] = None
  println(some.toRight("missing"))
  println(none.toRight("missing"))
}

Either ke Option

toOption membuang kesalahan: Right(x) menjadi Some(x) dan Left(_) menjadi None. Gunakan ini ketika alasan kegagalan tidak lagi penting.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(42)
  val l: Either[String, Int] = Left("err")
  println(r.toOption)
  println(l.toOption)
}

Try ke Option

Try.toOption mengubah Success menjadi Some dan Failure menjadi None, dengan menelan pengecualian.

import scala.util.Try

@main def run(): Unit = {
  println(Try("7".toInt).toOption)
  println(Try("x".toInt).toOption)
}

Try ke Either

Try.toEither menghasilkan Either[Throwable, T]: Success menjadi Right, sedangkan Failure menjadi Left(throwable). Dengan demikian, pengecualian dipertahankan sebagai nilai kiri bertipe.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try("7".toInt).toEither
  val no = Try("x".toInt).toEither
  println(ok)
  println(no.left.map(_.getMessage))
}

Either ke Try

Tidak ada fitur bawaan langsung untuk mengubah Either menjadi Try dengan kesalahan biasa, tetapi Anda dapat membuatnya: bungkus Right dalam Success dan Left dalam Failure yang membawa pengecualian.

import scala.util.{Try, Success, Failure}

object Main {
  def toTry(e: Either[String, Int]): Try[Int] = e match {
    case Right(v) => Success(v)
    case Left(m)  => Failure(new RuntimeException(m))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Right(1)))
    println(toTry(Left("bad")))
  }
}

Option ke Try

Konversikan Option menjadi Try dengan memilih pengecualian untuk kasus kosong. Ini berguna ketika API mengharapkan Try.

import scala.util.{Try, Success, Failure}

object Main {
  def toTry[A](o: Option[A]): Try[A] = o match {
    case Some(v) => Success(v)
    case None    => Failure(new NoSuchElementException("empty"))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Some(9)))
    println(toTry(None))
  }
}

Menormalkan Alur

Pencampuran tipe menimbulkan hambatan. Pendekatan yang umum adalah mengonversi semuanya menjadi Either dengan tipe kesalahan yang seragam sejak awal, lalu menyusunnya secara bebas.

import scala.util.Try

object Main {
  def parse(s: String): Either[String, Int] =
    Try(s.toInt).toEither.left.map(_ => s"invalid: $s")

  def lookup(n: Int): Either[String, String] =
    Map(1 -> "one", 2 -> "two").get(n).toRight(s"no entry for $n")

  def main(args: Array[String]): Unit = {
    val result = for {
      n <- parse("2")
      w <- lookup(n)
    } yield w
    println(result)
  }
}

getOrElse pada Berbagai Tipe

Ketiga tipe tersebut mendukung getOrElse untuk mengambil nilai atau menyediakan nilai bawaan. Ini sering menjadi langkah terakhir untuk keluar dari dunia penanganan kesalahan.

import scala.util.Try

@main def run(): Unit = {
  val a = Some(1).getOrElse(0)
  val b = (Right(2): Either[String, Int]).getOrElse(0)
  val c = Try("x".toInt).getOrElse(0)
  println(s"$a $b $c")
}

Memilih Tipe yang Tepat

Panduan:

  • Gunakan Option ketika ketiadaan nilai tidak memerlukan penjelasan.
  • Gunakan Either ketika Anda menginginkan nilai kesalahan khusus domain.
  • Gunakan Try pada batas yang berinteraksi dengan kode Java atau pustaka yang melempar pengecualian.

Contoh Menyeluruh

Membaca kode yang melempar pengecualian dengan Try, mengonversinya menjadi Either untuk kesalahan domain, lalu menjadi Option untuk pemanggil yang hanya peduli pada ada atau tidaknya nilai.

import scala.util.Try

object Main {
  def safeDiv(a: Int, b: Int): Option[Int] =
    Try(a / b).toEither.left.map(_ => "math error").toOption

  def main(args: Array[String]): Unit = {
    println(safeDiv(10, 2))
    println(safeDiv(10, 0))
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang konversi.

Rangkuman

Anda telah mempelajari cara mengonversi antara Option, Either, dan Try:

  • Option.toRight → Either; Either.toOption → Option.
  • Try.toOption dan Try.toEither menjembatani pengecualian menjadi nilai.
  • Normalkan alur menjadi satu tipe kesalahan sejak awal.
  • Pilih tipe yang sesuai dengan banyaknya detail kesalahan yang Anda perlukan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengonversi Antar-Tipe” gratis?

Ya — teks lengkap “Mengonversi Antar-Tipe” 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 “Mengonversi Antar-Tipe”?

Option, Either, Try. 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 “Mengonversi Antar-Tipe” 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