หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน
ทำให้ตรรกะเงื่อนไขอ่านง่ายและดูแลรักษาได้
หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน
กรณีที่นิพจน์แบบสามทางมีประโยชน์
นิพจน์แบบสามทางเพียงหนึ่งรายการจะสะอาดและอ่านง่ายเมื่อใช้เลือกจากสองทางอย่างง่าย ปัญหาจะเริ่มขึ้นเมื่อซ้อนนิพจน์แบบสามทางหนึ่งรายการไว้ภายในอีกรายการ
let temp = 10
let label = temp < 0 ? "Freezing" : "Above zero"
print(label)นิพจน์แบบสามทางที่ซ้อนกัน
คุณสามารถซ้อนนิพจน์แบบสามทางเพื่อจัดการมากกว่าสองกรณีได้ แต่ผลลัพธ์จะอ่านเข้าใจได้ยากอย่างรวดเร็ว
let score = 75
let grade = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : "F"
print(grade)เหตุใดการซ้อนจึงทำให้ยุ่งยาก
นิพจน์แบบสามทางที่ซ้อนกันบังคับให้ผู้อ่านต้องติดตามในใจว่าเครื่องหมายโคลอนใดจับคู่กับเครื่องหมายคำถามใด ความผิดพลาดเล็กน้อยอาจเปลี่ยนพฤติกรรมของโปรแกรมโดยไม่แสดงข้อผิดพลาด
ควรให้ความชัดเจนมาก่อนความแพรวพราว
let value = 5
let text = value > 0 ? "positive" : value < 0 ? "negative" : "zero"
print(text)ปรับโครงสร้างเป็น if/else if
การตัดสินใจหลายทางแบบเดียวกันจะอ่านเข้าใจได้ดีกว่ามากเมื่อเขียนเป็นสายคำสั่ง if / else if / else โดยให้แต่ละแขนงอยู่คนละบรรทัด
let score = 75
let grade: String
if score >= 90 {
grade = "A"
} else if score >= 80 {
grade = "B"
} else if score >= 70 {
grade = "C"
} else {
grade = "F"
}
print(grade)ใช้ switch แทน
สำหรับการตัดสินใจตามช่วงค่า การใช้ switch กับช่วงค่ามักเป็นทางเลือกที่สะอาดที่สุด
let score = 85
let grade: String
switch score {
case 90...100: grade = "A"
case 80..<90: grade = "B"
case 70..<80: grade = "C"
default: grade = "F"
}
print(grade)แยกเป็นฟังก์ชัน
เมื่อมีการใช้การตัดสินใจซ้ำ ให้ย้ายการตัดสินใจนั้นไปไว้ในฟังก์ชันที่ตั้งชื่อสื่อความหมาย จุดเรียกใช้จะอธิบายตัวเองได้
func gradeLetter(for score: Int) -> String {
if score >= 90 { return "A" }
if score >= 80 { return "B" }
if score >= 70 { return "C" }
return "F"
}
print(gradeLetter(for: 64))นิพจน์แบบสามทางหนึ่งรายการไม่เป็นปัญหา
กฎไม่ได้หมายความว่า “ห้ามใช้นิพจน์แบบสามทางโดยเด็ดขาด” นิพจน์แบบสามทางที่แบนราบเพียงหนึ่งรายการสำหรับการเลือกสองทางที่ชัดเจน ถือเป็นรูปแบบที่เป็นธรรมชาติของ Swift
let isAdmin = true
let role = isAdmin ? "Admin" : "User"
print(role)ให้ความสำคัญกับการอ่านง่ายมากกว่าความสั้น
โค้ดที่สั้นกว่าไม่ได้ดีกว่าเสมอไป หากผู้ตรวจทานต้องหยุดเพื่อถอดความหมายของบรรทัดหนึ่ง ควรเลือกรูปแบบที่ยาวกว่าแต่ชัดเจนกว่า
let stock = 0
let availability = stock > 0 ? "In stock" : "Sold out"
print(availability)หลีกเลี่ยงผลข้างเคียงในนิพจน์แบบสามทาง
ให้ทั้งสองแขนงของนิพจน์แบบสามทางเป็นเพียงค่าที่เรียบง่าย การซ่อนการเรียกฟังก์ชันที่มีผลข้างเคียงไว้ในนิพจน์แบบสามทางทำให้โค้ดคาดเดาได้ยาก
let level = 2
let points = level == 1 ? 100 : 200
print(points)การรวมกับเงื่อนไขที่ตั้งชื่อ
หากเงื่อนไขซับซ้อน ให้จัดเก็บเงื่อนไขนั้นไว้ในค่าบูลีนที่ตั้งชื่อก่อน แล้วจึงใช้นิพจน์แบบสามทางหนึ่งรายการ ชื่อจะช่วยอธิบายเจตนา
let age = 20
let hasLicense = true
let eligible = age >= 18 && hasLicense
let result = eligible ? "Approved" : "Denied"
print(result)ตัวอย่างหลายทางที่ชัดเจน
ลองเปรียบเทียบสายคำสั่ง if ที่อ่านง่ายนี้กับนิพจน์แบบสามทางที่ซ้อนกันก่อนหน้านี้ ทั้งสองแบบให้คำตอบเดียวกัน แต่แบบนี้ดูแลรักษาได้ง่าย
let value = -3
let sign: String
if value > 0 {
sign = "positive"
} else if value < 0 {
sign = "negative"
} else {
sign = "zero"
}
print(sign)ตรวจสอบความเข้าใจ
เลือกแนวปฏิบัติที่ดีที่สุด
สรุป: การหลีกเลี่ยงนิพจน์แบบสามทางที่ซ้อนกัน
ใช้นิพจน์แบบสามทางที่แบนราบเพียงหนึ่งรายการสำหรับการเลือกสองทาง สำหรับสามกรณีขึ้นไป ให้เลือกใช้ if/else if หรือ switch ให้ความสำคัญกับการอ่านง่าย เพื่อให้ตัวคุณในอนาคตติดตามตรรกะได้
let n = 7
let parity = n % 2 == 0 ? "even" : "odd"
print(parity)คำถามที่พบบ่อย
บทเรียน “หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน”
ทำให้ตรรกะเงื่อนไขอ่านง่ายและดูแลรักษาได้ คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Swift Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม
ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ค่า Bool และนิพจน์
- ตัวดำเนินการเงื่อนไขแบบสามส่วน
- หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน
- เมธอดบูลีนและการสลับค่า