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

ตัวดำเนินการเชื่อมออปชันแนล ?.

เรียกใช้เมธอดและเข้าถึงคุณสมบัติของออปชันแนลโดยไม่ทำให้โปรแกรมขัดข้อง

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

ยินดีต้อนรับ

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

ตัวดำเนินการ ?.

```swift struct Address { var city: String } struct Person { var address: Address? } let alice = Person(address: Address(city: "Istanbul")) let bob = Person(address: nil) print(alice.address?.city) // Optional("Istanbul") print(bob.address?.city) // nil ```

การเชื่อมต่อหลายระดับ

สายโซ่สามารถซ้อนลึกได้ตามต้องการ: ```swift struct Company { var ceo: Person? } let company = Company(ceo: alice) let city = company.ceo?.address?.city print(city ?? "Unknown") // "Istanbul" ``` หาก `ceo` หรือ `address` เป็น nil ค่า `city` จะกลายเป็น nil

การเรียกใช้เมธอดผ่านการเชื่อมต่อ

สามารถเรียกใช้เมธอดผ่านการเชื่อมต่อออปชันนัลได้เช่นกัน: ```swift var name: String? = "alice" let upper = name?.uppercased() // Optional("ALICE") name = nil let upper2 = name?.uppercased() // nil ``` ชนิดของค่าที่คืนจะกลายเป็นออปชันนัล: `String` จะกลายเป็น `String?`

การใช้ตัวห้อยผ่านการเชื่อมต่อ

```swift var dict: [String: [Int]]? = ["scores": [10, 20, 30]] let first = dict?["scores"]?[0] // Optional(10) dict = nil let none = dict?["scores"]?[0] // nil ``` ตัวห้อยทำงานเช่นเดียวกับคุณสมบัติและเมธอดเมื่ออยู่ในสายโซ่

การเชื่อมต่อจะสร้างค่าออปชันนัล

แม้ผลลัพธ์สุดท้ายจะไม่ใช่ออปชันนัล แต่การเชื่อมต่อจะห่อผลลัพธ์นั้นเป็นออปชันนัล: ```swift struct Cat { var lives: Int = 9 } var cat: Cat? = Cat() let lives = cat?.lives // Int? not Int ``` แกะค่าด้วย `??`, `if let` หรือ `guard let` ตามความเหมาะสม

การกำหนดค่าผ่านการเชื่อมโยงแบบออปชันนัล

คุณสามารถกำหนดค่าพร็อพเพอร์ตีผ่านการเชื่อมโยงแบบออปชันนัลได้: ```swift var profile: UserProfile? = UserProfile() profile?.name = "Alice" ``` หาก `profile` เป็น nil การกำหนดค่าจะถูกเพิกเฉยโดยไม่มีข้อความแจ้งเตือน (แอปจะไม่ขัดข้อง)

การเรียกเมทอดที่คืนค่า Void ผ่านการเชื่อมโยง

```swift var manager: SoundManager? manager?.play() // silently ignored if nil ``` การเรียกนี้จะคืนค่า `Void?` — เป็น `()` หากไม่ใช่ nil และเป็น `nil` หากออปชันนัลมีค่าเป็น nil คุณสามารถตรวจสอบผลลัพธ์เพื่อดูว่าการเรียกเกิดขึ้นหรือไม่

การเชื่อมโยงแบบออปชันนัลเทียบกับการแกะค่าแบบบังคับ

```swift // Forced unwrap — crashes if nil: let city = alice.address!.city // Optional chaining — safe: let city = alice.address?.city ``` ควรเลือกใช้การเชื่อมโยงแบบออปชันนัลเสมอ ใช้ `!` เฉพาะเมื่อคุณแน่ใจว่าไม่มีทางเกิด nil

การใช้ร่วมกับ ?? เพื่อกำหนดค่าเริ่มต้น

เชื่อม `??` ต่อท้ายการเชื่อมโยงแบบออปชันนัลเพื่อกำหนดค่าเริ่มต้นได้อย่างกระชับ: ```swift let displayCity = user.profile?.address?.city ?? "Unknown City" let count = database?.records?.count ?? 0 ``` การเชื่อมโยงทั้งหมดจะให้ค่าหนึ่งค่า หรือใช้ค่าเริ่มต้นแทน

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

หากส่วนใดส่วนหนึ่งในการเชื่อมโยงแบบออปชันนัลมีค่าเป็น `nil` นิพจน์ทั้งหมดจะคืนค่าอะไร

สรุป

ประเด็นสำคัญ: • `?.` ใช้เข้าถึงพร็อพเพอร์ตี เรียกเมทอด และใช้ซับสคริปต์กับออปชันนัลอย่างปลอดภัย • หากส่วนใดส่วนหนึ่งมีค่าเป็น nil การเชื่อมโยงทั้งหมดจะคืนค่า nil • ชนิดของผลลัพธ์จะเป็นออปชันนัลเสมอ แม้ว่าค่าสุดท้ายตามปกติจะไม่ใช่ออปชันนัลก็ตาม • ใช้ `?.` ร่วมกับ `??` เพื่อสร้างรูปแบบการเข้าถึงอย่างปลอดภัยพร้อมค่าเริ่มต้น • เลือกใช้ `?.` แทน `!` เพื่อหลีกเลี่ยงการขัดข้อง ถัดไป: ออปชันนัลที่แกะค่าโดยนัย

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

บทเรียน “ตัวดำเนินการเชื่อมออปชันแนล ?.” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ตัวดำเนินการเชื่อมออปชันแนล ?.” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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. การผูกค่าด้วย if let และ guard let
  2. การรวมค่า nil และตัวดำเนินการสามส่วนกับออปชันแนล
  3. ตัวดำเนินการเชื่อมออปชันแนล ?.
  4. ออปชันแนลที่แกะค่าโดยนัยและเวลาที่ควรหลีกเลี่ยง
← กลับไปที่ Swift Academy