0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Either untuk Error

Left dan Right.

Either untuk Error adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 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.

Mengapa Either?

Either merepresentasikan nilai yang dapat berupa salah satu dari dua kemungkinan. Ini adalah cara idiomatis untuk memodelkan komputasi yang mungkin gagal dengan informasi tentang kegagalannya.

  • Left secara konvensional menyimpan kesalahan.
  • Right secara konvensional menyimpan nilai keberhasilan.

Berbeda dari Option, yang hanya memberi tahu bahwa sesuatu tidak ada, Either memberi tahu Anda apa yang salah.

Tipe Either

Either[A, B] adalah sifat tersegel dengan dua subtipe: Left[A] dan Right[B].

Pengingatnya: Right berarti benar, sedangkan Left adalah kesalahan. Konvensi ini memungkinkan map dan flatMap beroperasi pada sisi keberhasilan secara otomatis.

val ok: Either[String, Int] = Right(42)
val err: Either[String, Int] = Left("boom")
println(ok)
println(err)

Mengembalikan Either dari Fungsi

Fungsi yang dapat gagal mengembalikan Either, bukan melempar pengecualian. Dengan demikian, pemanggil dapat menangani kedua hasil secara eksplisit.

object Main {
  def parseAge(s: String): Either[String, Int] =
    s.toIntOption match {
      case Some(n) if n >= 0 => Right(n)
      case Some(_)          => Left("age cannot be negative")
      case None             => Left("not a number")
    }

  def main(args: Array[String]): Unit = {
    println(parseAge("30"))
    println(parseAge("-5"))
    println(parseAge("x"))
  }
}

Pencocokan Pola pada Either

Cara paling langsung untuk menggunakan Either adalah pencocokan pola. Anda menangani Left dan Right secara terpisah.

@main def run(): Unit = {
  val result: Either[String, Int] = Right(10)
  val msg = result match {
    case Right(value) => s"Got value: $value"
    case Left(error)  => s"Failed: $error"
  }
  println(msg)
}

fold: Menggabungkan Kedua Sisi

fold menerima dua fungsi: satu untuk Left dan satu untuk Right, lalu menghasilkan satu hasil dengan tipe yang sama.

Ini merupakan alternatif ringkas untuk pencocokan pola ketika Anda ingin mendapatkan kembali sebuah nilai.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(7)
  val label = r.fold(
    err => s"error: $err",
    num => s"double is ${num * 2}"
  )
  println(label)
}

map Beroperasi pada Right

map mengubah nilai Right dan membiarkan Left tanpa perubahan. Inilah perilaku yang berpihak pada Right dari Either Scala (sejak 2.12).

@main def run(): Unit = {
  val ok: Either[String, Int]  = Right(5)
  val no: Either[String, Int]  = Left("missing")
  println(ok.map(_ + 1))
  println(no.map(_ + 1))
}

getOrElse dan Nilai Bawaan

getOrElse mengambil nilai Right atau mengembalikan nilai pengganti ketika Either berupa Left.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(99)
  val no: Either[String, Int] = Left("oops")
  println(ok.getOrElse(0))
  println(no.getOrElse(0))
}

swap: Menukar Kedua Sisi

swap menukar Left dan Right. Ini berguna ketika Anda ingin beroperasi pada sisi kesalahan menggunakan metode yang berpihak pada Right.

@main def run(): Unit = {
  val err: Either[String, Int] = Left("bad input")
  val swapped = err.swap.map(_.toUpperCase)
  println(swapped)
}

isLeft dan isRight

Pemeriksaan boolean singkat memungkinkan Anda membuat percabangan tanpa pencocokan pola lengkap.

  • isRight mengembalikan true untuk keberhasilan.
  • isLeft mengembalikan true untuk kesalahan.
@main def run(): Unit = {
  val r: Either[String, Int] = Right(1)
  println(r.isRight)
  println(r.isLeft)
}

toOption: Membuang Kesalahan

Ketika Anda tidak lagi peduli mengapa sesuatu gagal, toOption mengonversi Either menjadi Option: Right(x) menjadi Some(x) dan Left(_) menjadi None.

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

Contoh Validasi

Menggabungkan semuanya: validasikan nama pengguna dengan mengembalikan kesalahan bertipe saat terjadi kegagalan.

object Main {
  def validate(name: String): Either[String, String] =
    if (name.isEmpty) Left("empty name")
    else if (name.length > 10) Left("name too long")
    else Right(name)

  def main(args: Array[String]): Unit = {
    println(validate("alice"))
    println(validate(""))
    println(validate("verylongusername"))
  }
}

Pemeriksaan singkat

Uji pemahaman Anda tentang konvensi Either.

Ringkasan

Anda telah mempelajari cara memodelkan kesalahan dengan Either:

  • Right = berhasil, Left = kesalahan (berpihak pada Right).
  • Gunakan dengan pencocokan pola atau fold.
  • Ubah nilai keberhasilan dengan map; sediakan nilai bawaan dengan getOrElse.
  • Tukar sisi dengan swap; konversikan dengan toOption.

Selanjutnya, Anda akan menangani pengecualian dengan Try.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Either untuk Error” gratis?

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

Left dan Right. 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 1 dari 4.

Berapa lama pelajaran “Either untuk Error” 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