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

การรวมค่า nil และตัวดำเนินการสามส่วนกับออปชันแนล

ใช้ ?? สำหรับค่าเริ่มต้นและเชื่อมตัวดำเนินการรวมค่า nil หลายตัว

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

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

ตัวดำเนินการรวมค่า nil `??` จะให้ค่าเริ่มต้นเมื่อออปชันนัลเป็น nil เมื่อใช้ร่วมกับตัวดำเนินการสามส่วน จะช่วยให้จัดการออปชันนัลได้อย่างกระชับและสื่อความหมายชัดเจน

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

```swift let name: String? = nil let display = name ?? "Guest" print(display) // "Guest" let known: String? = "Alice" print(known ?? "Guest") // "Alice" ``` หากออปชันนัลไม่เป็น nil ระบบจะใช้ค่าที่แกะแล้ว มิฉะนั้นจะใช้ค่าเริ่มต้น

การประเมินแบบลัดวงจร

ด้านขวาของ `??` จะถูกประเมินก็ต่อเมื่อด้านซ้ายเป็น nil เท่านั้น: ```swift func expensiveDefault() -> String { print("Computing...") return "Default" } let val: String? = "Existing" let result = val ?? expensiveDefault() // expensiveDefault not called ```

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

เชื่อมตัวดำเนินการ `??` หลายตัวเพื่อทดลองใช้ค่าทดแทนหลายค่า: ```swift let primary: String? = nil let secondary: String? = nil let fallback = "Anonymous" let user = primary ?? secondary ?? fallback print(user) // "Anonymous" ``` การประเมินจะหยุดที่ค่าแรกที่ไม่เป็น nil

?? กับคุณสมบัติที่คำนวณค่า

```swift struct Config { var theme: String? var displayTheme: String { theme ?? "light" } } var c = Config() print(c.displayTheme) // "light" c.theme = "dark" print(c.displayTheme) // "dark" ``` นี่เป็นรูปแบบการกำหนดค่าเริ่มต้นที่สะอาดสำหรับคุณสมบัติที่คำนวณค่า

ตัวดำเนินการสามส่วนกับออปชันนัล

ตัวดำเนินการสามส่วน `condition ? a : b` สามารถใช้กับการตรวจสอบออปชันนัลได้: ```swift let score: Int? = 85 let label = score != nil ? "\(score!)" : "No score" ``` แต่โดยทั่วไป `??` จะอ่านง่ายกว่า: ```swift let label = score.map { "\($0)" } ?? "No score" ```

Optional.map สำหรับการแปลงค่า

แปลงค่าที่ออปชันนัลห่อไว้โดยไม่ต้องแกะค่า: ```swift let maybeInt: Int? = 42 let maybeStr = maybeInt.map { "Value: \($0)" } // Optional("Value: 42") let nilInt: Int? = nil let nilStr = nilInt.map { "Value: \($0)" } // nil ```

flatMap สำหรับการเชื่อมต่อออปชันนัล

ใช้ `flatMap` เมื่อการแปลงค่าเองคืนค่าเป็นออปชันนัล: ```swift let str: String? = "123" let num = str.flatMap { Int($0) } // Optional(123) let bad: String? = "abc" let nil2 = bad.flatMap { Int($0) } // nil ```

ตัวดำเนินการกำหนดค่า ??= (ไม่มีมาให้ในตัว)

Swift ไม่มี `??=` มาให้ในตัว แต่คุณสามารถจำลองการทำงานได้: ```swift var cache: [String: Int] = [:] // Assign only if nil: if cache["key"] == nil { cache["key"] = expensiveCompute() } // Or with a helper: func ??= (lhs: inout T?, rhs: @autoclosure () -> T) { if lhs == nil { lhs = rhs() } } ```

แนวทางเพื่อให้อ่านง่าย

เลือกเครื่องมือให้เหมาะสม: • `??` — ค่าเริ่มต้นแบบง่าย • `if let` — เมื่อต้องใช้ค่าที่แกะแล้วในหลายคำสั่ง • `guard let` — เงื่อนไขเบื้องต้นและการออกก่อนกำหนด • `.map` / `.flatMap` — แปลงค่าโดยไม่ต้องแกะค่า หลีกเลี่ยงการแกะค่าฝืนด้วย `!` เว้นแต่กรณี nil จะไม่เกิดขึ้นได้จริง

ตรวจสอบความเข้าใจอย่างรวดเร็ว

`optional ?? default` จะคืนค่าอะไรเมื่อ `optional` เป็น `nil`

สรุป

ประเด็นสำคัญ: • `a ?? b` — คืนค่าของ `a` หากไม่เป็น nil มิฉะนั้นคืนค่า `b` • ลัดวงจร: จะประเมิน `b` ก็ต่อเมื่อ `a` เป็น nil • เชื่อมได้: `a ?? b ?? c` • `.map` แปลงค่าที่ถูกห่อไว้ ส่วน `.flatMap` จัดการกรณีที่การแปลงค่าคืนค่าเป็นออปชันนัล • ควรใช้ `??` แทนตัวดำเนินการสามส่วนร่วมกับการแกะค่าฝืน ถัดไป: การเชื่อมต่อออปชันนัลด้วย `?.`

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

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

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

คุณจะเรียนรู้อะไรในบทเรียน “การรวมค่า nil และตัวดำเนินการสามส่วนกับออปชันแนล”

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

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

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

บทเรียน “การรวมค่า nil และตัวดำเนินการสามส่วนกับออปชันแนล” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การผูกค่าด้วย if let และ guard let
  2. การรวมค่า nil และตัวดำเนินการสามส่วนกับออปชันแนล
  3. ตัวดำเนินการเชื่อมออปชันแนล ?.
  4. ออปชันแนลที่แกะค่าโดยนัยและเวลาที่ควรหลีกเลี่ยง
← กลับไปที่ Swift Academy