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

นิพจน์ match

แยกแขนงตามรูปร่าง

นิพจน์ match เป็นบทเรียน 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 บทเรียน

match คืออะไร

match เป็นโครงสร้างสำหรับแตกแขนงที่ทรงพลังของ Scala โดยระบุค่าและรูปแบบ case หลายรายการ จากนั้นโปรแกรมจะทำงานที่แขนงแรกที่ตรงกัน

ลองนึกภาพว่าเป็นคำสั่ง switch ที่มีความสามารถมากกว่าและอยู่ในรูปนิพจน์

ไวยากรณ์พื้นฐาน

เขียนในรูปแบบ value match { case pattern => result } โดยแต่ละ case จะกำหนดรูปแบบและโค้ดที่จะทำงานเมื่อรูปแบบนั้นตรงกัน

เนื่องจาก match เป็นนิพจน์ ทั้งชุดจึงส่งคืนค่าได้

object Main {
  def main(args: Array[String]): Unit = {
    val n = 2
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case 3 => "three"
    }
    println(word)
  }
}

กรณีไวลด์การ์ด

ขีดล่าง _ คือไวลด์การ์ดที่ตรงกับอะไรก็ได้ ใช้เป็นกรณีค่าเริ่มต้นที่ครอบคลุมทุกอย่างไว้ท้ายสุด

หากไม่มีไวลด์การ์ด ค่าที่ไม่ตรงกับกรณีใดจะทำให้เกิด MatchError ขณะทำงาน

object Main {
  def main(args: Array[String]): Unit = {
    val n = 9
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
    }
    println(word)
  }
}

การจับคู่สตริง

รูปแบบไม่ได้จำกัดเฉพาะตัวเลข คุณสามารถจับคู่กับค่าคงที่ชนิดสตริงได้โดยตรง

object Main {
  def main(args: Array[String]): Unit = {
    val cmd = "start"
    val msg = cmd match {
      case "start" => "Starting up"
      case "stop"  => "Shutting down"
      case _       => "Unknown command"
    }
    println(msg)
  }
}

match ส่งคืนค่า

เนื่องจากแต่ละแขนงส่งคืนค่า คุณจึงกำหนดผลลัพธ์ของ match ให้กับ val หรือใช้แทรกไว้ภายในนิพจน์ได้

วิธีนี้ช่วยให้โค้ดสะอาดและหลีกเลี่ยงตัวแปรที่เปลี่ยนค่าได้

object Main {
  def main(args: Array[String]): Unit = {
    val light = "red"
    println(s"Action: " + (light match {
      case "red"   => "stop"
      case "green" => "go"
      case _       => "caution"
    }))
  }
}

การรวมกรณี

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

object Main {
  def main(args: Array[String]): Unit = {
    val day = "Sat"
    val kind = day match {
      case "Sat" | "Sun" => "weekend"
      case _             => "weekday"
    }
    println(kind)
  }
}

match ในฟังก์ชัน

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

object Main {
  def describe(n: Int): String = n match {
    case 0 => "zero"
    case 1 => "one"
    case _ => "other"
  }
  def main(args: Array[String]): Unit = {
    println(describe(0))
    println(describe(5))
  }
}

การผูกค่าทั้งหมด

คุณสามารถผูกค่าที่จับคู่ได้กับชื่อในกรณีไวลด์การ์ดโดยใช้ case other => จากนั้นจึงใช้ other ภายในแขนงนั้นได้

object Main {
  def main(args: Array[String]): Unit = {
    val n = 42
    val result = n match {
      case 0     => "nothing"
      case other => s"got $other"
    }
    println(result)
  }
}

ลำดับมีความสำคัญ

ระบบจะตรวจสอบกรณีต่าง ๆ จากบนลงล่าง และการจับคู่ ครั้งแรกจะเป็นผลลัพธ์ที่เลือก วางรูปแบบที่เฉพาะเจาะจงกว่าไว้ก่อนรูปแบบทั่วไป

หากวางไวลด์การ์ดเร็วเกินไป ไวลด์การ์ดนั้นจะบดบังกรณีที่อยู่ด้านล่าง

object Main {
  def main(args: Array[String]): Unit = {
    val n = 1
    val msg = n match {
      case 1 => "specific one"
      case _ => "anything else"
    }
    println(msg)
  }
}

เหตุใดจึงใช้ match

การจับคู่รูปแบบเป็นแนวคิดสำคัญของ Scala เนื่องจาก:

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

นำทุกอย่างมารวมกัน

นี่คือตัวจำแนกขนาดเล็กที่ใช้ค่าคงที่ กรณีที่รวมกัน และค่าปริยาย

object Main {
  def grade(score: Int): String = score match {
    case 10 | 9 => "excellent"
    case 8 | 7  => "good"
    case _      => "keep trying"
  }
  def main(args: Array[String]): Unit = {
    println(grade(9))
    println(grade(7))
    println(grade(3))
  }
}

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

ทดสอบความเข้าใจของคุณเกี่ยวกับนิพจน์ match

สรุปทบทวน

คุณได้เรียนรู้พื้นฐานของ match ดังนี้:

  • ไวยากรณ์คือ value match { case pattern => result }
  • _ คือไวลด์การ์ดที่ครอบคลุมทุกกรณี
  • รวมค่าเข้าด้วยกันด้วย |
  • match เป็นนิพจน์ที่ส่งคืนค่า
  • ระบบลองกรณีต่าง ๆ จากบนลงล่าง โดยการจับคู่ครั้งแรกจะเป็นผลลัพธ์

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

บทเรียน “นิพจน์ match” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “นิพจน์ match”

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

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

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

บทเรียน “นิพจน์ match” ใช้เวลานานแค่ไหน

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

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

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

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

  1. นิพจน์ match
  2. การจับคู่ชนิดและค่า
  3. การ์ดและการผูกค่า
  4. การแยกโครงสร้าง
← กลับไปที่ Scala for Backend Engineering & Functional Programming