0Pricing
Swift Academy · บทเรียน

หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน

ทำให้ตรรกะเงื่อนไขอ่านง่ายและดูแลรักษาได้

หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. ค่า Bool และนิพจน์
  2. ตัวดำเนินการเงื่อนไขแบบสามส่วน
  3. หลีกเลี่ยงเงื่อนไขสามส่วนซ้อนกัน
  4. เมธอดบูลีนและการสลับค่า
← กลับไปที่ Swift Academy