Swift Academy · บทเรียน

guard let สำหรับการออกก่อนกำหนด

แกะค่าและออกก่อนกำหนดเมื่อไม่สำเร็จ เพื่อลดการซ้อนกัน

บทเรียน 2 จาก 413 ขั้นตอน

guard let สำหรับการออกก่อนกำหนด เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

แนวคิดของ guard

guard ตรวจสอบเงื่อนไข และหากเงื่อนไขไม่ผ่านก็จะออกจากขอบเขตปัจจุบัน วิธีนี้ออกแบบมาสำหรับการออกจากฟังก์ชันตั้งแต่ต้น เพื่อให้เส้นทางกรณีปกติไม่ต้องเยื้องบรรทัด

func greet(_ name: String?) {
    guard let name else {
        print("No name")
        return
    }
    print("Hello, \(name)")
}
greet("Ada")
greet(nil)

ไวยากรณ์ guard let

เขียน guard let value = optional else { return } ต่างจาก if let ตรงที่ค่าที่แกะแล้วจะยังคงอยู่ในขอบเขต หลังจากนั้น

func double(_ text: String) {
    guard let n = Int(text) else {
        print("Not a number")
        return
    }
    print(n * 2)
}
double("8")
double("x")

ค่าจะยังคงใช้ได้ต่อไป

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

func length(of text: String?) {
    guard let text else { return }
    let count = text.count
    print(count)
}
length("hello")

บล็อกกรณีอื่นต้องออกจากขอบเขต

บล็อกกรณีอื่นของคำสั่งตรวจสอบล่วงหน้าต้องออกจากขอบเขตปัจจุบัน: return, break, continue หรือ throw โดยคอมไพเลอร์จะบังคับใช้กฎนี้

func process(_ value: Int?) {
    guard let value else {
        return
    }
    print("Processing \(value)")
}
process(99)

การผูกค่าแบบตรวจสอบล่วงหน้าโดยย่อ

เช่นเดียวกับการผูกค่าแบบเงื่อนไข คำสั่งตรวจสอบล่วงหน้ารองรับรูปแบบย่อ: guard let name else { ... } เมื่อชื่อมีรูปแบบตรงกัน

func show(_ name: String?) {
    guard let name else {
        print("missing")
        return
    }
    print(name)
}
show("Kai")

เส้นทางปกติที่ราบเรียบ

ข้อดีสำคัญของคำสั่งตรวจสอบล่วงหน้าคือเส้นทางปกติที่ราบเรียบและอ่านง่าย ลองเปรียบเทียบโครงสร้างการผูกค่าแบบเงื่อนไขที่ซ้อนกันเป็นชั้น ๆ กับคำสั่งตรวจสอบล่วงหน้าหลายชุด

func register(name: String?, age: Int?) {
    guard let name else { return }
    guard let age else { return }
    print("\(name) is \(age)")
}
register(name: "Mia", age: 28)

ตรวจสอบเงื่อนไขทั่วไป

คำสั่งตรวจสอบล่วงหน้าใช้ได้กับเงื่อนไขบูลีนใด ๆ ไม่ใช่เฉพาะค่าทางเลือกเท่านั้น guard count > 0 else { return } จะออกจากการทำงานตั้งแต่เนิ่น ๆ

func divide(_ a: Int, by b: Int) {
    guard b != 0 else {
        print("Cannot divide by zero")
        return
    }
    print(a / b)
}
divide(10, by: 2)
divide(10, by: 0)

คำสั่งตรวจสอบล่วงหน้าในลูป

ภายในการวนซ้ำ คำสั่งตรวจสอบล่วงหน้าสามารถใช้ continue เพื่อข้ามรอบหนึ่งเมื่อข้อมูลหายไป

let inputs = ["1", "x", "3"]
for item in inputs {
    guard let n = Int(item) else { continue }
    print(n * 10)
}

การผูกค่าหลายค่าในคำสั่งเดียว

คำสั่งตรวจสอบล่วงหน้าเพียงคำสั่งเดียวสามารถแยกค่าทางเลือกหลายค่าออกจากค่าที่ห่อหุ้มได้ โดยคั่นด้วยจุลภาค ทุกค่าต้องสำเร็จจึงจะดำเนินการต่อได้

func combine(_ a: String?, _ b: String?) {
    guard let a, let b else { return }
    print(a + b)
}
combine("foo", "bar")

ตรวจสอบเงื่อนไขเพิ่มเติม

คุณสามารถเพิ่มเงื่อนไขบูลีนหลังการผูกค่าโดยคั่นด้วยจุลภาค เพื่อกำหนดเงื่อนไขให้ละเอียดขึ้นว่าคำสั่งตรวจสอบล่วงหน้าจะผ่านเมื่อใด

func validate(_ text: String?) {
    guard let text, !text.isEmpty else {
        print("invalid")
        return
    }
    print("ok: \(text)")
}
validate("")
validate("hi")

เมื่อใดควรเลือกใช้คำสั่งตรวจสอบล่วงหน้า

ใช้คำสั่งตรวจสอบล่วงหน้าสำหรับเงื่อนไขเบื้องต้นที่ด้านบนของฟังก์ชัน และใช้การผูกค่าแบบเงื่อนไขเมื่อคุณต้องการค่าเพียงชั่วครู่ภายในแขนงหนึ่ง

func area(width: Int?, height: Int?) -> Int {
    guard let width, let height else { return 0 }
    return width * height
}
print(area(width: 3, height: 4))

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

ทดสอบการผูกค่าแบบตรวจสอบล่วงหน้า

สรุป: การผูกค่าแบบตรวจสอบล่วงหน้าเพื่อออกแต่เนิ่น ๆ

guard let value else { return } จะแยกค่าทางเลือกออกจากค่าที่ห่อหุ้ม และทำให้ค่านั้นอยู่ในขอบเขตหลังจากนั้น บล็อกกรณีอื่นต้องออกจากการทำงาน ซึ่งช่วยให้เส้นทางปกติราบเรียบและอ่านง่าย

func f(_ x: Int?) {
    guard let x else { return }
    print(x)
}
f(5)
เริ่มต้นได้ฟรี

เรียนรู้ Swift ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
122
บทเรียน
409

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

บทเรียน “guard let สำหรับการออกก่อนกำหนด” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “guard let สำหรับการออกก่อนกำหนด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “guard let สำหรับการออกก่อนกำหนด”

แกะค่าและออกก่อนกำหนดเมื่อไม่สำเร็จ เพื่อลดการซ้อนกัน คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่

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

บทเรียน “guard let สำหรับการออกก่อนกำหนด” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม

ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. if let และการผูกค่าแบบย่อ
  2. guard let สำหรับการออกก่อนกำหนด
  3. การผูกค่าเสริมหลายค่า
  4. รูปแบบค่าเสริมใน switch และ for
← กลับไปที่ Swift Academy