Scala for Backend Engineering & Functional Programming · Pelajaran

Try, Success, Failure

Penanganan pengecualian.

Try, Success, Failure adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 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.

Apa itu Try?

Try[T] merepresentasikan komputasi yang dapat menghasilkan nilai atau melempar pengecualian. Tipe ini memiliki dua subtipe:

Success[T] membungkus hasil normal.
Failure membungkus Throwable.

Tipe ini mengubah kode yang melempar pengecualian menjadi nilai yang dapat Anda rangkai.

Mengimpor Try

Try berada di dalam scala.util. Bungkus ekspresi apa pun yang mungkin melempar pengecualian di dalam Try { ... }, dan Try akan menangkap pengecualian yang tidak fatal untuk Anda.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try(10 / 2)
  val bad = Try(10 / 0)
  println(ok)
  println(bad)
}

Success dan Failure

Try yang selesai secara normal menjadi Success yang menyimpan nilai; Try yang melempar pengecualian menjadi Failure yang menyimpan pengecualian tersebut.

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

@main def run(): Unit = {
  val result = Try("123".toInt)
  result match {
    case Success(n) => println(s"parsed: $n")
    case Failure(e) => println(s"failed: ${e.getMessage}")
  }
}

Pencocokan Pola untuk Kegagalan

Ketika kode yang dibungkus melempar pengecualian, Anda dapat memeriksa pengecualian di dalam Failure. Di sini, kesalahan penguraian ditangkap dengan rapi.

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

@main def run(): Unit = {
  val result = Try("abc".toInt)
  result match {
    case Success(n) => println(s"got $n")
    case Failure(e) => println(s"error type: ${e.getClass.getSimpleName}")
  }
}

getOrElse dengan Try

getOrElse mengembalikan nilai keberhasilan atau nilai bawaan ketika Try gagal. Dengan demikian, pengecualian tidak perlu dilempar sama sekali.

import scala.util.Try

@main def run(): Unit = {
  val n = Try("oops".toInt).getOrElse(-1)
  println(n)
}

map pada Try

map mengubah nilai Success. Jika nilai awalnya berupa Failure, atau jika fungsi pemetaan melempar pengecualian, hasilnya tetap berupa Failure.

import scala.util.Try

@main def run(): Unit = {
  val doubled = Try("21".toInt).map(_ * 2)
  val failed  = Try("x".toInt).map(_ * 2)
  println(doubled)
  println(failed)
}

recover: Menangani Pengecualian

recover memungkinkan Anda mengubah Failure kembali menjadi Success dengan menangani pengecualian tertentu menggunakan fungsi parsial.

import scala.util.Try

@main def run(): Unit = {
  val safe = Try("x".toInt).recover {
    case _: NumberFormatException => 0
  }
  println(safe)
}

recoverWith

recoverWith mirip dengan recover, tetapi penanganannya mengembalikan Try lain, bukan nilai biasa. Gunakan ini ketika proses pemulihan itu sendiri mungkin gagal.

import scala.util.Try

@main def run(): Unit = {
  val result = Try("x".toInt).recoverWith {
    case _: NumberFormatException => Try("42".toInt)
  }
  println(result)
}

toEither dan toOption

Try dapat dikonversi dengan mudah ke tipe kesalahan lain:

toOption: Success menjadi Some, Failure menjadi None.
toEither: Success menjadi Right, Failure menjadi Left(throwable).

import scala.util.Try

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

Merangkai dengan flatMap

flatMap mengurutkan komputasi yang masing-masing mengembalikan Try. Jika salah satu tahap gagal, seluruh rangkaian langsung berhenti dan menghasilkan Failure tersebut.

import scala.util.Try

object Main {
  def half(n: Int): Try[Int] = Try(if (n % 2 == 0) n / 2 else throw new RuntimeException("odd"))

  def main(args: Array[String]): Unit = {
    println(Try("8".toInt).flatMap(half))
    println(Try("7".toInt).flatMap(half))
  }
}

Try dibandingkan try/catch

Try mengubah pengecualian menjadi nilai, sehingga Anda dapat menggunakan map, flatMap, dan menggabungkan hasil tanpa blok try/catch bertingkat. Try hanya menangkap pengecualian yang tidak fatal; kesalahan serius seperti OutOfMemoryError tetap diteruskan.

Pemeriksaan singkat

Uji pengetahuan Anda tentang Try.

Ringkasan

Anda telah mempelajari penanganan pengecualian dengan Try:

Try { ... } menangkap pengecualian yang tidak fatal sebagai Failure, dan hasil normal sebagai Success.
Ubah dengan map/flatMap; pulihkan dengan recover/recoverWith.
Sediakan nilai bawaan dengan getOrElse.
Konversikan dengan toOption dan toEither.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Try, Success, Failure” gratis?

Ya — teks lengkap “Try, Success, Failure” 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 “Try, Success, Failure”?

Penanganan pengecualian. 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 2 dari 4.

Berapa lama pelajaran “Try, Success, Failure” 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