การอนุมานคลาสของชนิด
อินสแตนซ์อัตโนมัติ
การอนุมานคลาสของชนิด เป็นบทเรียน 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 บทเรียน
การสร้างต่อยอดคืออะไร
การสร้างคลาสประเภทต่อยอดจะสร้างอินสแตนซ์โดยอัตโนมัติจากโครงสร้างของชนิดข้อมูล ทำให้คุณไม่ต้องเขียนโค้ดซ้ำสำหรับคลาสกรณีแต่ละคลาส คอมไพเลอร์จะสร้างอินสแตนซ์จากฟิลด์ของชนิดข้อมูล
ปัญหาโค้ดซ้ำซ้อน
หากไม่มีการสร้างต่อยอด คลาสกรณีใหม่ทุกคลาสจะต้องมีอินสแตนซ์ที่เขียนด้วยตนเอง สำหรับ Show ที่ใช้กับคลาสกรณี 20 คลาส นั่นหมายถึงนิยามที่แทบเหมือนกัน 20 ชุด การสร้างต่อยอดช่วยขจัดการทำซ้ำนี้
การประกอบด้วยตนเองก่อน
ก่อนใช้การสร้างต่อยอดโดยอัตโนมัติ โปรดสังเกตว่าคุณสามารถประกอบอินสแตนซ์ด้วยตนเองจากอินสแตนซ์ของฟิลด์ได้ นี่คือหลักการที่การสร้างต่อยอดทำให้เป็นอัตโนมัติ
trait Show[A] { def show(a: A): String }
case class User(name: String, age: Int)
object Main {
implicit val strShow: Show[String] = s => s
implicit val intShow: Show[Int] = _.toString
implicit val userShow: Show[User] = (u: User) =>
s"User(${strShow.show(u.name)}, ${intShow.show(u.age)})"
def main(args: Array[String]): Unit = {
println(userShow.show(User("Ann", 30)))
}
}อินสแตนซ์แบบอุปนัย
การสร้างต่อยอดทำงานแบบอุปนัย โดยกำหนดอินสแตนซ์สำหรับชนิดข้อมูลพื้นฐานก่อน แล้วจึงรวมเข้าด้วยกันสำหรับผลคูณ (คลาสกรณี) และผลบวก (trait แบบปิดผนึก) อินสแตนซ์ที่สร้างต่อยอดจะประกอบขึ้นจากส่วนต่าง ๆ
คีย์เวิร์ด derives ใน Scala 3
Scala 3 รองรับส่วนคำสั่ง derives คลาสประเภทที่มีเมธอด derived สามารถแนบเข้ากับชนิดข้อมูลได้ด้วยคีย์เวิร์ดเดียว (ตัวอย่างเชิงแนวคิด ต้องใช้คลาสประเภทที่รองรับการสร้างต่อยอด)
enum Color derives CanEqual:
case Red, Green, Blue
@main def run(): Unit =
println(Color.Red == Color.Red)การสร้างต่อยอดด้วย Mirror
การสร้างโดยอนุมานของ Scala 3 ใช้ scala.deriving.Mirror ซึ่งเปิดเผยโครงสร้างของชนิดข้อมูล (ชนิดและชื่อของฟิลด์) ในขณะคอมไพล์ เมธอด derived จะพับผ่านอินสแตนซ์ขององค์ประกอบใน mirror เพื่อสร้างทั้งโครงสร้างขึ้นมา
การสร้างโดยอนุมานแบบกึ่งอัตโนมัติ
ไลบรารีอย่าง Cats รองรับการสร้างโดยอนุมานแบบ กึ่งอัตโนมัติ: คุณเลือกใช้เป็นรายชนิดข้อมูลด้วยคำสั่งบรรทัดเดียว เช่น deriveShow ทำให้เวลาคอมไพล์คาดเดาได้ง่ายขึ้น พร้อมลดโค้ดซ้ำซ้อน
อัตโนมัติเทียบกับกึ่งอัตโนมัติ
มีสองรูปแบบ:
- อัตโนมัติ: อินสแตนซ์จะปรากฏขึ้นทุกที่ที่จำเป็นผ่านการนำเข้าแบบ implicit สะดวก แต่การคอมไพล์อาจช้าลง
- กึ่งอัตโนมัติ: คุณเขียนคำสั่ง derive อย่างชัดเจนหนึ่งครั้งต่อชนิดข้อมูล ควบคุมได้มากกว่าและสร้างงานได้เร็วกว่า
การสร้างโดยอนุมานสำหรับลำดับชั้นของ sealed trait
สำหรับลำดับชั้นแบบ sealed (ชนิดผลรวม) อินสแตนซ์ที่สร้างโดยอนุมานจะเลือกทำงานตามชนิดย่อยของค่าที่ได้รับ ตัวอย่างนี้แสดงแนวคิดด้วยเวอร์ชันที่เขียนเอง ซึ่งการสร้างโดยอนุมานจะทำให้เป็นอัตโนมัติ
trait Show[A] { def show(a: A): String }
sealed trait Shape
case class Circle(r: Int) extends Shape
case class Square(s: Int) extends Shape
object Main {
implicit val shapeShow: Show[Shape] = {
case Circle(r) => s"Circle($r)"
case Square(s) => s"Square($s)"
}
def main(args: Array[String]): Unit = {
println(shapeShow.show(Circle(5)))
println(shapeShow.show(Square(3)))
}
}ควรใช้การสร้างโดยอนุมานเมื่อใด
เลือกใช้การสร้างโดยอนุมานเมื่อ:
- คุณมีชนิดข้อมูลจำนวนมากที่ต้องใช้ type class เดียวกัน (ตัวเข้ารหัส JSON, Show, Eq)
- อินสแตนซ์สามารถสร้างได้โดยตรงจากโครงสร้าง
ให้เขียนอินสแตนซ์ด้วยตนเองเมื่อพฤติกรรมเป็นแบบกำหนดเองหรือมีความสำคัญต่อประสิทธิภาพ
ตัวอย่างความเท่าเทียมทั่วไป
ความเท่าเทียมเป็น type class แบบคลาสสิกที่สร้างโดยอนุมานได้ การใช้ == มาตรฐานกับคลาสแบบ case เองก็เป็นความเท่าเทียมเชิงโครงสร้างรูปแบบหนึ่งที่คอมไพเลอร์สร้างให้คุณ
case class Coord(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
println(Coord(1, 2) == Coord(1, 2))
println(Coord(1, 2) == Coord(3, 4))
}
}ตรวจสอบความเข้าใจอย่างรวดเร็ว
ทดสอบความเข้าใจของคุณเกี่ยวกับการสร้างโดยอนุมาน
สรุปทบทวน
คุณได้เรียนรู้เรื่อง การสร้าง type class โดยอนุมาน:
- อินสแตนซ์ถูกสร้างแบบอุปนัยจากอินสแตนซ์ของฟิลด์หรือ case
- Scala 3 ใช้
Mirrorและคีย์เวิร์ดderives - เลือกใช้แบบ อัตโนมัติ เพื่อความสะดวก หรือแบบ กึ่งอัตโนมัติ เพื่อการควบคุม
- ใช้เพื่อลดโค้ดซ้ำซ้อนในชนิดข้อมูลจำนวนมาก
คำถามที่พบบ่อย
บทเรียน “การอนุมานคลาสของชนิด” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การอนุมานคลาสของชนิด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “การอนุมานคลาสของชนิด” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- รูปแบบคลาสของชนิด
- การกำหนดอินสแตนซ์
- คลาสของชนิดที่พบบ่อย
- การอนุมานคลาสของชนิด