0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

การจัดการข้อผิดพลาดใน IO

handleError

การจัดการข้อผิดพลาดใน IO เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

ข้อผิดพลาดในรูปของค่า

ใน Cats Effect ค่า IO สามารถ ล้มเหลวได้ ความล้มเหลวเป็นส่วนหนึ่งของค่า คุณจึงตรวจสอบและกู้คืนได้โดยไม่ต้องใช้ try/catch ที่ไร้โครงสร้าง

การยกข้อผิดพลาด

ใช้ IO.raiseError เพื่อสร้าง IO ที่ล้มเหลวอย่างชัดเจนด้วยข้อยกเว้นที่เลือก

import cats.effect.IO

val failed: IO[Int] =
  IO.raiseError(new RuntimeException("boom"))

handleError

handleError กู้คืน IO ที่ล้มเหลวด้วยการจัดหาค่าสำรองที่คำนวณจากข้อผิดพลาด ผลลัพธ์คือ IO ที่ไม่สามารถล้มเหลวได้ ณ จุดนี้

import cats.effect.IO

val safe: IO[Int] =
  IO.raiseError[Int](new RuntimeException("x"))
    .handleError(_ => -1)

handleErrorWith

handleErrorWith กู้คืนด้วย IO อีกรายการหนึ่ง ดังนั้นค่าสำรองเองจึงอาจมีผลกระทบได้ (เช่น การบันทึกข้อมูล การลองใหม่ หรือการคืนค่าเริ่มต้น)

import cats.effect.IO

val recovered: IO[Int] =
  IO(throw new RuntimeException("fail"))
    .handleErrorWith(e => IO.println(s"caught: ${e.getMessage}").as(0))

attempt

attempt แปลง IO[A] เป็น IO[Either[Throwable, A]] โดยทำให้ข้อผิดพลาดกลายเป็นค่า เพื่อให้คุณจับคู่รูปแบบกับมันได้

import cats.effect.IO

val e: IO[Either[Throwable, Int]] =
  IO.raiseError[Int](new RuntimeException("oops")).attempt

การจับคู่รูปแบบด้วย attempt

หลังจากใช้ attempt คุณสามารถแยกแขนงตามความสำเร็จหรือความล้มเหลวด้วย flatMap ปกติบน Either

import cats.effect.IO

val prog: IO[Unit] = IO(10 / 2).attempt.flatMap {
  case Right(v) => IO.println(s"ok: $v")
  case Left(e)  => IO.println(s"err: ${e.getMessage}")
}

redeem

redeem จัดการทั้งสองแขนงด้วยการเรียกครั้งเดียว: ฟังก์ชันหนึ่งสำหรับข้อผิดพลาดและอีกฟังก์ชันสำหรับความสำเร็จ โดยทั้งคู่คืนค่าแบบธรรมดา

import cats.effect.IO

val label: IO[String] =
  IO(42).redeem(e => s"failed: $e", v => s"value: $v")

redeemWith

redeemWith คล้ายกับ redeem แต่แต่ละแขนงคืนค่าเป็น IO จึงสามารถจัดการทั้งความสำเร็จและความล้มเหลวด้วยผลกระทบได้

import cats.effect.IO

val prog: IO[Unit] = IO(42).redeemWith(
  e => IO.println(s"err: $e"),
  v => IO.println(s"got: $v")
)

การล้างข้อมูลด้วย guarantee

guarantee จะเรียกใช้ตัวเก็บกวาดไม่ว่าผลกระทบจะสำเร็จหรือล้มเหลว — เหมาะอย่างยิ่งสำหรับการคืนทรัพยากรหรือบันทึกการเสร็จสิ้น

import cats.effect.IO

val prog: IO[Int] =
  IO(compute()).guarantee(IO.println("done"))

def compute(): Int = 7

การลองใหม่เมื่อเกิดความล้มเหลว

คุณสามารถสร้างการลองใหม่อย่างง่ายได้โดยกู้คืนแบบเรียกตัวเองซ้ำด้วย handleErrorWith และลดตัวนับลงจนเหลือศูนย์

import cats.effect.IO

def retry[A](io: IO[A], n: Int): IO[A] =
  if (n <= 0) io
  else io.handleErrorWith(_ => retry(io, n - 1))

try/catch ใน Scala ปกติ

ลองเปรียบเทียบกับการจัดการข้อผิดพลาดแบบประเมินผลทันทีใน Scala ปกติ ตัวดำเนินการของ IO มอบความปลอดภัยแบบเดียวกันในรูปของค่าบริสุทธิ์ที่ประกอบได้

object Main {
  def main(args: Array[String]): Unit = {
    val result = try { 10 / 0 } catch { case _: ArithmeticException => -1 }
    println(s"result: $result")
  }
}

ตรวจสอบอย่างรวดเร็ว

เมธอดใดเปลี่ยน IO[A] เป็น IO[Either[Throwable, A]]

สรุปทบทวน

คุณจัดการข้อผิดพลาดใน IO ด้วย:

  • raiseError เพื่อทำให้ล้มเหลวอย่างชัดเจน
  • handleError / handleErrorWith เพื่อกู้คืน
  • attempt เพื่อทำให้ Either เป็นค่า
  • redeem / redeemWith สำหรับทั้งสองแขนง
  • guarantee สำหรับการล้างข้อมูล

คุณเรียนหลักสูตร Cats และ IO จบแล้ว

คำถามที่พบบ่อย

บทเรียน “การจัดการข้อผิดพลาดใน IO” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การจัดการข้อผิดพลาดใน IO” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การจัดการข้อผิดพลาดใน IO”

handleError คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การจัดการข้อผิดพลาดใน IO” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. คลาสของชนิดใน Cats
  2. โมนาด IO
  3. การประกอบ IO
  4. การจัดการข้อผิดพลาดใน IO
← กลับไปที่ Scala for Backend Engineering & Functional Programming