แยกส่วนทูเพิล
ดึงค่ากลับออกมา
แยกส่วนทูเพิล เป็นบทเรียน 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 บทเรียน
การดึงค่าออกมา
การสร้างทูเพิลเป็นเพียงครึ่งหนึ่งของเรื่อง หากต้องการใช้ค่าภายใน คุณต้องดึงค่าเหล่านั้นออกมา
Scala มีสองวิธีหลัก ได้แก่ ตัวเข้าถึงตามหมายเลขและการแยกโครงสร้างตามรูปแบบ บทเรียนนี้ครอบคลุมทั้งสองวิธี
การเข้าถึงตามตำแหน่ง
สมาชิกทุกตัวของทูเพิลมีตำแหน่งที่อ่านได้ด้วย ._1 ._2 และอื่น ๆ
โปรดสังเกตว่าตำแหน่งเริ่มที่ หนึ่ง ไม่ใช่ศูนย์ ดังนั้น ._1 คือสมาชิกตัวแรก
val person = ("Alice", 30)
println(person._1)
println(person._2)การใช้ตัวเข้าถึงในโค้ด
ตัวเข้าถึงตามตำแหน่งมีประโยชน์เมื่อคุณต้องการสมาชิกเพียงตัวเดียว
ในที่นี้เราอ่านอายุจากคู่แล้วบวกเพิ่มหนึ่ง ตัวเข้าถึงจะคืนชนิดเดิมของสมาชิก ดังนั้นจึงคำนวณได้โดยตรง
val record = ("Bob", 42)
val nextYear = record._2 + 1
println(nextYear)การแยกโครงสร้างด้วย val
การอ่าน ._1 และ ._2 อาจทำให้ติดตามโค้ดได้ยาก การแยกโครงสร้างช่วยให้คุณตั้งชื่อสมาชิกแต่ละตัวได้พร้อมกัน
รูปแบบ val นี้ผูก name และ age ไว้ในบรรทัดเดียว
val (name, age) = ("Cara", 25)
println(name)
println(age)เหตุผลที่การแยกโครงสร้างช่วยได้
ตัวแปรที่มีชื่ออ่านเข้าใจได้ดีกว่าตำแหน่งที่เป็นหมายเลข
เมื่อเปรียบเทียบ age กับ person._2 แบบแยกโครงสร้างจะสื่อเจตนาได้ชัดเจนและหลีกเลี่ยงข้อผิดพลาดจากการนับตำแหน่งคลาดเคลื่อน
val (city, population) = ("Lyon", 500000)
println(s"$city has $population people")การแยกโครงสร้างสามสมาชิก
การแยกโครงสร้างใช้ได้กับทูเพิลทุกขนาด ไม่ใช่แค่คู่
ในที่นี้ทูเพิลสามสมาชิกถูกแยกเป็นตัวแปรที่มีชื่อสามตัวในคำสั่งเดียว
val (id, label, active) = (7, "task", true)
println(id)
println(label)
println(active)การละเว้นด้วยขีดล่าง
บางครั้งคุณต้องการเพียงบางค่า ให้ใช้ขีดล่าง _ เพื่อข้ามตำแหน่ง
ในที่นี้เราเก็บเฉพาะชื่อและละเว้นอายุทั้งหมด
val (name, _) = ("Dana", 40)
println(name)การแยกโครงสร้างผลลัพธ์ของฟังก์ชัน
ฟังก์ชันที่ส่งคืนทูเพิลเหมาะกับการแยกโครงสร้างโดยธรรมชาติ
คุณสามารถตั้งชื่อค่าที่ส่งคืนทั้งสองค่าตรงจุดที่เรียกฟังก์ชัน ทำให้ผลลัพธ์อธิบายตัวเองได้
def minMax(a: Int, b: Int) = (a min b, a max b)
val (low, high) = minMax(8, 3)
println(low)
println(high)การสลับคู่
ทูเพิลสองสมาชิกมีเมธอด swap ในตัวสำหรับสลับสมาชิก
เมธอดนี้จะคืนคู่ใหม่ที่มีลำดับกลับด้าน ซึ่งมีประโยชน์ในบางครั้ง
val pair = ("a", 1)
println(pair.swap)การแยกโครงสร้างใน for
เมื่อวนซ้ำผ่านคอลเลกชันของคู่ คุณสามารถแยกโครงสร้างภายในส่วนหัวของลูปได้
แต่ละคู่จะถูกแยกเป็น key และ value โดยอัตโนมัติในทุกครั้งที่วนซ้ำ
val pairs = List(("a", 1), ("b", 2))
for ((key, value) <- pairs) println(s"$key=$value")ชนิดยังคงเดิม
การแยกโครงสร้างไม่ทำให้ข้อมูลชนิดสูญหาย ตัวแปรที่มีชื่อแต่ละตัวจะคงชนิดที่ตรงกับตำแหน่งของตน
ดังนั้นใน val (n, age) = ("Eve", 33) n เป็น String และ age เป็น Int พร้อมใช้งานอย่างปลอดภัยตามชนิด
val (n, age) = ("Eve", 33)
println(n.length)
println(age * 2)ตรวจสอบอย่างรวดเร็ว
ทดสอบสิ่งที่คุณเรียนรู้เกี่ยวกับการแยกโครงสร้างทูเพิล
สรุปทบทวน
คุณสามารถดึงค่าจากทูเพิลด้วยตัวเข้าถึงตามตำแหน่ง เช่น ._1 (เริ่มนับจากหนึ่ง) หรือใช้การแยกโครงสร้างที่ชัดเจนกว่า เช่น val (a, b) = pair
ขีดล่างใช้ข้ามตำแหน่งที่ไม่ต้องการ การแยกโครงสร้างใช้ในลูป for ได้ และชนิดจะคงเดิมเสมอ ต่อไปคุณจะสำรวจช่วง
คำถามที่พบบ่อย
บทเรียน “แยกส่วนทูเพิล” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “แยกส่วนทูเพิล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- สร้างทูเพิล
- แยกส่วนทูเพิล
- สร้างช่วงค่า
- ช่วงค่าในลูป