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

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

Left และ Right

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

ทำไมต้องใช้ Either

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

  • โดยทั่วไป Left ใช้เก็บข้อผิดพลาด
  • โดยทั่วไป Right ใช้เก็บค่าที่สำเร็จ

ต่างจาก Option ซึ่งบอกเพียงว่า มีบางอย่างหายไป ส่วน Either จะบอกว่า เกิดข้อผิดพลาดอะไรขึ้น

ชนิด Either

Either[A, B] เป็นลักษณะปิดที่มีชนิดย่อยสองชนิด ได้แก่ Left[A] และ Right[B]

วิธีจำคือ Right คือด้านที่ถูกต้อง ส่วน Left คือข้อผิดพลาด แบบแผนนี้ทำให้ map และ flatMap ทำงานกับด้านที่สำเร็จโดยอัตโนมัติ

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

การคืนค่า Either จากฟังก์ชัน

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

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

การจับคู่รูปแบบบน Either

วิธีใช้ Either ที่ตรงไปตรงมาที่สุดคือการจับคู่รูปแบบ โดยจัดการ Left และ Right แยกจากกัน

@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: รวมทั้งสองด้าน

fold รับฟังก์ชันสองรายการ ได้แก่ฟังก์ชันหนึ่งสำหรับ Left และอีกฟังก์ชันสำหรับ Right แล้วสร้างผลลัพธ์เดียวที่มีชนิดร่วมกัน

วิธีนี้กระชับกว่าการจับคู่รูปแบบเมื่อคุณต้องการคืนค่า

@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 ทำงานกับ Right

map แปลงค่าใน Right และปล่อยให้ Left อยู่เหมือนเดิม นี่คือพฤติกรรมที่ให้น้ำหนักกับ Right ของ Either ใน Scala ตั้งแต่เวอร์ชัน 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 และค่าเริ่มต้น

getOrElse ดึงค่าใน Right หรือคืนค่าทดแทนเมื่อ Either เป็น 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: สลับด้าน

swap สลับ Left กับ Right เหมาะเมื่อคุณต้องการทำงานกับด้านข้อผิดพลาดโดยใช้เมธอดที่ให้น้ำหนักกับ Right

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

isLeft และ isRight

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

  • isRight คืนค่าเป็นจริงเมื่อเป็นผลลัพธ์ที่สำเร็จ
  • isLeft คืนค่าเป็นจริงเมื่อเป็นข้อผิดพลาด
@main def run(): Unit = {
  val r: Either[String, Int] = Right(1)
  println(r.isRight)
  println(r.isLeft)
}

toOption: ทิ้งข้อผิดพลาด

เมื่อคุณไม่สนใจแล้วว่า เหตุใด จึงล้มเหลว toOption จะแปลง Either เป็น Option: Right(x) จะกลายเป็น Some(x) และ Left(_) จะกลายเป็น 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)
}

ตัวอย่างการตรวจสอบความถูกต้อง

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

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับแบบแผนของ Either

สรุปทบทวน

คุณได้เรียนรู้การจำลองข้อผิดพลาดด้วย Either แล้ว:

  • Right = สำเร็จ, Left = ข้อผิดพลาด โดยให้น้ำหนักกับ Right
  • ใช้ การจับคู่รูปแบบ หรือ fold เพื่อดึงผลลัพธ์
  • แปลงผลลัพธ์ที่สำเร็จด้วย map และกำหนดค่าเริ่มต้นด้วย getOrElse
  • สลับด้านด้วย swap และแปลงเป็นตัวเลือกด้วย toOption

ถัดไป คุณจะจัดการข้อยกเว้นด้วย Try

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

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

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

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

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

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

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

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

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

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

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

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

  1. Either สำหรับข้อผิดพลาด
  2. Try, Success, Failure
  3. การประกอบ Either
  4. การแปลงระหว่างชนิด
← กลับไปที่ Scala for Backend Engineering & Functional Programming