Scala for Backend Engineering & Functional Programming · Pelajaran

Option, Try, Either untuk Galat

Terapkan penanganan galat yang tangguh menggunakan `Option` untuk ketiadaan nilai, `Try` untuk pengecualian, dan `Either` untuk jalur kegagalan atau keberhasilan yang berbeda.

Option, Try, Either untuk Galat adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 3 dari 3. 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 3 pelajaran total.

Menangani Error dengan Baik

Dalam pemrograman, segala sesuatu tidak selalu berjalan sesuai rencana. File mungkin tidak ada, permintaan jaringan dapat gagal, atau perhitungan dapat menghasilkan hasil yang tidak valid.

Bagaimana cara menulis kode tangguh yang dapat menangani situasi ini dengan baik?
Scala menyediakan alat yang kuat untuk mengelola error dan nilai yang tidak ada tanpa harus menggunakan `null` atau melempar pengecualian di mana-mana.

Masalah dengan Null

Banyak bahasa menggunakan null untuk menyatakan tidak adanya nilai. Namun, null sering menjadi sumber bug seperti NullPointerException yang ditakuti.

Scala tidak menganjurkan penggunaan null. Sebagai gantinya, Scala menyediakan tipe yang secara eksplisit menyatakan apakah suatu nilai mungkin tidak ada, sehingga kode Anda lebih aman dan lebih mudah dipahami.

Memperkenalkan Scala Option

Option[A] adalah wadah yang dapat menyimpan nilai bertipe A (diwakili oleh Some[A]) atau sama sekali tidak menyimpan nilai (diwakili oleh None).

Option memaksa Anda mempertimbangkan kondisi ketika suatu nilai mungkin tidak ada.
Hal ini mencegah NullPointerExceptions yang tidak terduga dan membuat kode Anda lebih eksplisit.

Option dalam Praktik: Some & None

Mari kita lihat cara kerja Option. Kita akan mendefinisikan fungsi yang mungkin mengembalikan nama atau mungkin tidak, bergantung pada ID.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val user1 = findUser(1) // Some("Alice")
    val user2 = findUser(2) // None

    println(s"User 1: $user1")
    println(s"User 2: $user2")
  }
}

Bekerja dengan Option: map & getOrElse

Anda dapat mengubah nilai di dalam Option menggunakan map, atau memberikan nilai bawaan jika nilainya adalah None menggunakan getOrElse.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val userGreeting = findUser(1).map(name => s"Hello, $name!")
    val defaultGreeting = findUser(2).map(name => s"Hello, $name!").getOrElse("Hello, Guest!")

    println(s"User greeting: $userGreeting")
    println(s"Default greeting: $defaultGreeting")
  }
}

Memperkenalkan Scala Try

Jika Option menangani nilai yang tidak ada, Try[A] dirancang untuk menangani perhitungan yang mungkin melempar pengecualian.

Try dapat berupa Success[A] (jika perhitungan selesai secara normal) atau Failure[Throwable] (jika terjadi pengecualian).
Try membungkus pengecualian sehingga Anda dapat menanganinya secara fungsional.

Try dalam Praktik: Success & Failure

Mari kita mendefinisikan fungsi yang mungkin melempar pengecualian (misalnya, pembagian dengan nol) dan membungkus eksekusinya dalam Try.

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

object Main {
  def divide(a: Int, b: Int): Try[Int] = Try {
    a / b
  }

  def main(args: Array[String]): Unit = {
    val result1 = divide(10, 2) // Success(5)
    val result2 = divide(10, 0) // Failure(java.lang.ArithmeticException: / by zero)

    println(s"Result 1: $result1")
    println(s"Result 2: $result2")
  }
}

Bekerja dengan Try: recover & fold

Try menyediakan metode seperti recover untuk menangani pengecualian tertentu atau fold untuk memproses kasus berhasil dan gagal dengan rapi.

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

object Main {
  def parseNumber(s: String): Try[Int] = Try(s.toInt)

  def main(args: Array[String]): Unit = {
    val num1 = parseNumber("123").getOrElse(0)
    val num2 = parseNumber("abc").getOrElse(0)

    val message = parseNumber("456").fold(
      ex => s"Failed to parse: ${ex.getMessage}",
      num => s"Parsed number: $num"
    )

    println(s"Parsed num1: $num1")
    println(s"Parsed num2: $num2")
    println(s"Message: $message")
  }
}

Memperkenalkan Scala Either

Either[L, R] adalah tipe yang merepresentasikan salah satu dari dua kemungkinan nilai. Berdasarkan konvensi:

Left[L] merepresentasikan kegagalan (atau tipe error L).
Right[R] merepresentasikan keberhasilan (atau tipe hasil R).

Berbeda dari Try, Either memungkinkan Anda menentukan tipe yang bermakna untuk error, bukan hanya Throwable.

Either dalam Praktik: Left & Right

Berikut adalah fungsi yang memvalidasi email. Fungsi ini mengembalikan pesan error bertipe String (Left) atau email yang telah divalidasi (Right).

object Main {
  def validateEmail(email: String): Either[String, String] = {
    if (email.contains("@") && email.contains(".")) Right(email)
    else Left("Invalid email format")
  }

  def main(args: Array[String]): Unit = {
    val email1 = validateEmail("test@example.com") // Right("test@example.com")
    val email2 = validateEmail("invalid-email")   // Left("Invalid email format")

    println(s"Email 1: $email1")
    println(s"Email 2: $email2")
  }
}

Pemeriksaan Singkat: Penanganan Error

Anda sedang menulis fungsi yang membaca nilai konfigurasi dari sebuah peta. Jika kuncinya ada, Anda ingin mengubah nilai string-nya menjadi bilangan bulat. Jika kuncinya tidak ada atau konversinya gagal, Anda ingin mengembalikan nilai bawaan 0.

Kombinasi tipe dan metode Scala mana yang paling tepat untuk tugas ini?

Rangkuman: Option, Try, Either

Kita telah mempelajari tiga tipe Scala yang kuat untuk penanganan error yang tangguh:

Option[A]: Untuk menangani nilai yang tidak ada (Some[A] atau None).
Try[A]: Untuk membungkus perhitungan yang mungkin melempar pengecualian (Success[A] atau Failure[Throwable]).
Either[L, R]: Untuk merepresentasikan dua hasil yang berbeda, biasanya tipe kegagalan L dan tipe keberhasilan R (Left[L] atau Right[R]).

Menggunakan tipe-tipe ini membuat kode Scala Anda lebih aman, lebih eksplisit, dan lebih fungsional!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Option, Try, Either untuk Galat” gratis?

Ya — teks lengkap “Option, Try, Either untuk Galat” 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 3 pelajaran total.

Apa yang akan aku pelajari di “Option, Try, Either untuk Galat”?

Terapkan penanganan galat yang tangguh menggunakan `Option` untuk ketiadaan nilai, `Try` untuk pengecualian, dan `Either` untuk jalur kegagalan atau keberhasilan yang berbeda. 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 3.

Berapa lama pelajaran “Option, Try, Either untuk Galat” 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