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

Option, Try, Either สำหรับข้อผิดพลาด

บทเรียน 3 จาก 312 ขั้นตอน

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

การจัดการข้อผิดพลาดอย่างเหมาะสม

ในการเขียนโปรแกรม สิ่งต่าง ๆ ไม่ได้เป็นไปตามแผนเสมอไป ไฟล์อาจไม่มีอยู่ คำขอเครือข่ายอาจล้มเหลว หรือการคำนวณอาจนำไปสู่ผลลัพธ์ที่ไม่ถูกต้อง

เราจะเขียนโค้ดที่มีความทนทานและจัดการสถานการณ์เหล่านี้ได้อย่างเหมาะสมได้อย่างไร
Scala มีเครื่องมือที่ทรงพลังสำหรับจัดการข้อผิดพลาดและค่าที่หายไป โดยไม่ต้องพึ่งพา `null` หรือโยนข้อยกเว้นไปทั่วโค้ด

ปัญหาของ Null

ภาษาจำนวนมากใช้ null เพื่อแทนการไม่มีค่า อย่างไรก็ตาม null เป็นสาเหตุที่พบบ่อยของข้อบกพร่อง เช่น NullPointerException ที่น่าหวาดหวั่น

Scala ไม่สนับสนุนการใช้ null แต่มีชนิดข้อมูลที่ระบุอย่างชัดเจนว่าค่าอาจหายไปหรือไม่ ทำให้โค้ดปลอดภัยและเข้าใจได้ง่ายขึ้น

ทำความรู้จัก Scala Option

Option[A] เป็นคอนเทนเนอร์ที่เก็บค่าได้หนึ่งค่าจากสองกรณี ได้แก่ ค่าชนิด A (แทนด้วย Some[A]) หรือไม่มีค่าเลย (แทนด้วย None)

บังคับให้คุณพิจารณากรณีที่ค่าอาจไม่มีอยู่
ช่วยป้องกัน NullPointerExceptions ที่ไม่คาดคิด และทำให้โค้ดสื่อความหมายได้ชัดเจนขึ้น

การใช้งาน Option: Some และ None

มาดูกันว่า Option ทำงานอย่างไร เราจะกำหนดฟังก์ชันที่อาจส่งคืนชื่อหรือไม่ส่งคืนก็ได้ ขึ้นอยู่กับ 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")
  }
}

การทำงานกับ Option: map และ getOrElse

คุณสามารถแปลงค่าภายใน Option โดยใช้ map หรือระบุค่าเริ่มต้นหากค่าเป็น None โดยใช้ 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")
  }
}

ทำความรู้จัก Scala Try

ขณะที่ Option ใช้จัดการค่าที่หายไป Try[A] ออกแบบมาเพื่อจัดการการคำนวณที่อาจโยนข้อยกเว้น

Try อาจเป็น Success[A] (หากการคำนวณเสร็จสมบูรณ์ตามปกติ) หรือ Failure[Throwable] (หากเกิดข้อยกเว้น)
ทำหน้าที่ห่อหุ้มข้อยกเว้น ทำให้คุณจัดการข้อยกเว้นด้วยแนวทางเชิงฟังก์ชันได้

การใช้งาน Try: Success และ Failure

มากำหนดฟังก์ชันที่อาจโยนข้อยกเว้น (เช่น การหารด้วยศูนย์) และห่อหุ้มการทำงานของฟังก์ชันนั้นไว้ใน 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")
  }
}

การทำงานกับ Try: recover และ fold

Try มีเมธอดอย่าง recover สำหรับจัดการข้อยกเว้นเฉพาะประเภท หรือ fold สำหรับประมวลผลทั้งกรณีสำเร็จและล้มเหลวอย่างเป็นระเบียบ

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")
  }
}

ทำความรู้จัก Scala Either

Either[L, R] เป็นชนิดข้อมูลที่แสดงค่าที่เป็นไปได้หนึ่งจากสองค่า ตามธรรมเนียมแล้ว:

Left[L] แทนความล้มเหลว (หรือชนิดข้อผิดพลาด L)
Right[R] แทนความสำเร็จ (หรือชนิดผลลัพธ์ R)

แตกต่างจาก Try ตรงที่ Either ช่วยให้คุณระบุชนิดข้อมูลที่มีความหมายสำหรับข้อผิดพลาดได้ ไม่จำกัดอยู่เพียง Throwable

การใช้งาน Either: Left และ Right

นี่คือตัวอย่างฟังก์ชันที่ตรวจสอบอีเมล ฟังก์ชันจะส่งคืนข้อความข้อผิดพลาดชนิด String (Left) หรืออีเมลที่ผ่านการตรวจสอบแล้ว (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")
  }
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว: การจัดการข้อผิดพลาด

คุณกำลังเขียนฟังก์ชันที่อ่านค่าการกำหนดค่าจากแผนที่ หากมีคีย์อยู่ คุณต้องการแปลงค่าสตริงของคีย์นั้นเป็นจำนวนเต็ม หากไม่มีคีย์หรือการแปลงล้มเหลว คุณต้องการส่งคืนค่าเริ่มต้นเป็น 0

การใช้ชนิดข้อมูลและเมธอดของ Scala ชุดใดจึงเหมาะสมที่สุดสำหรับงานนี้

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุป: Option, Try และ Either

เราได้สำรวจชนิดข้อมูล Scala ที่ทรงพลังสามชนิดสำหรับการจัดการข้อผิดพลาดอย่างมีประสิทธิภาพ:

Option[A]: ใช้จัดการกรณีที่ไม่มีค่า (Some[A] หรือ None)
Try[A]: ใช้ห่อหุ้มการคำนวณที่อาจโยนข้อยกเว้น (Success[A] หรือ Failure[Throwable])
Either[L, R]: ใช้แทนผลลัพธ์ที่แตกต่างกันสองแบบ โดยทั่วไปคือชนิดความล้มเหลว L และชนิดความสำเร็จ R (Left[L] หรือ Right[R])

การใช้ชนิดข้อมูลเหล่านี้ทำให้โค้ด Scala ปลอดภัยขึ้น สื่อความหมายได้ชัดเจนขึ้น และมีลักษณะเชิงฟังก์ชันมากขึ้น

เริ่มต้นได้ฟรี

เรียนรู้ Scala ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 143

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “Option, Try, Either สำหรับข้อผิดพลาด” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “Option, Try, Either สำหรับข้อผิดพลาด”

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

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

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

บทเรียน “Option, Try, Either สำหรับข้อผิดพลาด” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ Scala for Backend Engineering & Functional Programming