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

การจับคู่ชนิดและค่า

รูปแบบชนิด

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

รูปแบบตามชนิดข้อมูล

นอกจากการจับคู่ค่าคงที่แล้ว match ยังสามารถแตกแขนงตามชนิดข้อมูลของค่าได้ ซึ่งเรียกว่ารูปแบบตามชนิดข้อมูล

เขียนเป็น case x: Type => โดยแขนงนี้จะทำงานเมื่อค่าเป็นชนิดดังกล่าว และผูกค่าไว้กับ x

การจับคู่ตามชนิดข้อมูล

เมื่อค่ามีชนิดทั่วไปอย่าง Any คุณสามารถตรวจหาชนิดจริงของค่าด้วยรูปแบบตามชนิดข้อมูลได้

แต่ละ case x: T จะตรวจสอบชนิดขณะทำงาน

object Main {
  def describe(x: Any): String = x match {
    case i: Int    => "an Int"
    case s: String => "a String"
    case _         => "something else"
  }
  def main(args: Array[String]): Unit = {
    println(describe(5))
    println(describe("hi"))
    println(describe(3.14))
  }
}

การใช้ค่าที่ผูกไว้

ชื่อที่ผูกไว้จะมีชนิดเดียวกับค่าที่จับคู่ได้ ดังนั้นคุณจึงเรียกใช้เมธอดของค่านั้นอย่างปลอดภัยภายในแขนงดังกล่าว

ไม่จำเป็นต้องแปลงชนิด เพราะคอมไพเลอร์ทราบชนิดภายใน case อยู่แล้ว

object Main {
  def shout(x: Any): String = x match {
    case s: String => s.toUpperCase
    case i: Int    => (i * 2).toString
    case _         => "?"
  }
  def main(args: Array[String]): Unit = {
    println(shout("hello"))
    println(shout(21))
  }
}

ชนิดข้อมูลและค่าพร้อมกัน

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

object Main {
  def check(x: Any): String = x match {
    case 0       => "zero int"
    case i: Int  => s"nonzero int $i"
    case _       => "not an int"
  }
  def main(args: Array[String]): Unit = {
    println(check(0))
    println(check(7))
    println(check("x"))
  }
}

การจับคู่ Double และ Boolean

รูปแบบตามชนิดข้อมูลใช้ได้กับทุกชนิด รวมถึง Double, Boolean และ Char

object Main {
  def kind(x: Any): String = x match {
    case d: Double  => s"double $d"
    case b: Boolean => s"bool $b"
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(kind(2.5))
    println(kind(true))
  }
}

การจับคู่คอลเลกชันตามชนิดข้อมูล

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

object Main {
  def info(x: Any): String = x match {
    case l: List[_] => s"a list of size ${l.size}"
    case _          => "not a list"
  }
  def main(args: Array[String]): Unit = {
    println(info(List(1, 2, 3)))
    println(info("nope"))
  }
}

การใช้งานทั่วไป: การจัดการ Any

รูปแบบตามชนิดข้อมูลมีประโยชน์อย่างยิ่งเมื่อฟังก์ชันรับค่าเป็น Any และต้องตอบสนองแตกต่างกันตามชนิด เช่น การบันทึกข้อมูลการทำงานหรือการทำให้เป็นอนุกรม

object Main {
  def render(x: Any): String = x match {
    case i: Int    => s"int=$i"
    case d: Double => s"dbl=$d"
    case s: String => s"str=$s"
    case _         => "unknown"
  }
  def main(args: Array[String]): Unit = {
    List(1, 2.0, "three").foreach(v => println(render(v)))
  }
}

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

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

ควรเรียงลำดับจากเฉพาะเจาะจงที่สุดไปทั่วไปที่สุดเสมอ

object Main {
  def label(x: Any): String = x match {
    case s: String => "string first"
    case _: Any    => "anything"
  }
  def main(args: Array[String]): Unit = {
    println(label("hi"))
    println(label(99))
  }
}

ข้อควรระวังเรื่องการลบชนิดข้อมูล

ขณะทำงาน พารามิเตอร์ชนิดข้อมูลแบบทั่วไปจะถูกลบออก ดังนั้น List[Int] และ List[String] จึงดูเหมือนกัน การจับคู่กับ List[Int] จะตรวจสอบได้เพียงว่าเป็น List เท่านั้น

ใช้ List[_] เพื่อระบุเจตนาให้ชัดเจนและหลีกเลี่ยงคำเตือน

เหตุใดจึงใช้รูปแบบตามชนิดข้อมูล

รูปแบบตามชนิดข้อมูลช่วยให้คุณ:

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

รูปแบบเหล่านี้เป็นพื้นฐานสำคัญก่อนเรียนรู้การจับคู่กับคลาสกรณีและ ADT

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

รวมรูปแบบตามค่าและรูปแบบตามชนิดข้อมูลเพื่อจำแนกข้อมูลนำเข้าที่มีหลายชนิด

object Main {
  def classify(x: Any): String = x match {
    case 0          => "zero"
    case i: Int     => "int"
    case s: String  => "text of length " + s.length
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(classify(0))
    println(classify(5))
    println(classify("hey"))
  }
}

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

ทดสอบความรู้ของคุณเกี่ยวกับรูปแบบตามชนิดข้อมูล

สรุปทบทวน

คุณได้เรียนรู้การจับคู่ตามชนิดข้อมูล:

  • case x: Type จับคู่ตามชนิดขณะทำงานและผูกค่าไว้กับ x
  • ค่าที่ผูกไว้จะมีชนิดเดียวกับค่าที่จับคู่ได้ จึงไม่ต้องแปลงชนิด
  • ผสมรูปแบบตามค่าและชนิดข้อมูล โดยวางรูปแบบที่เฉพาะเจาะจงที่สุดก่อน
  • พารามิเตอร์ชนิดข้อมูลทั่วไปจะถูกลบออก จึงควรใช้ List[_]

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

บทเรียน “การจับคู่ชนิดและค่า” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การจับคู่ชนิดและค่า”

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

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

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

บทเรียน “การจับคู่ชนิดและค่า” ใช้เวลานานแค่ไหน

บทเรียน 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