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

การอ้างอิงแบบ weak และ unowned

เลือกใช้ weak (Optional) หรือ unowned (ไม่ใช่ Optional) เพื่อทำลายวงจรการอ้างอิง

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

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

การตัดวงจรการเก็บรักษาต้องใช้การอ้างอิงที่ไม่เพิ่มตัวนับ ARC โดย Swift มีอยู่สองแบบ ได้แก่ `weak` (เป็นออปชันแนลและเปลี่ยนเป็นศูนย์โดยอัตโนมัติ) กับ `unowned` (ไม่เป็นออปชันแนลและไม่ปลอดภัยหากเป็น nil)

การอ้างอิงแบบ weak

```swift class Owner { var pet: Pet? } class Pet { weak var owner: Owner? } // does not retain var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p p?.owner = o o = nil // Owner deinit — p.owner becomes nil automatically ```

weak เป็นออปชันแนลเสมอ

```swift class View { weak var delegate: ViewDelegate? } ``` `weak` ต้องประกาศเป็น `var` และเป็นออปชันแนล — Swift จะเปลี่ยนค่าเป็นศูนย์โดยอัตโนมัติเมื่อออบเจ็กต์ที่ถูกอ้างอิงถูกยกเลิกการจัดสรร

การอ้างอิงแบบ unowned

```swift class Customer { var card: CreditCard? } class CreditCard { unowned let customer: Customer // card always has a customer init(customer: Customer) { self.customer = customer } } ``` `unowned` จะไม่เก็บออบเจ็กต์ไว้และไม่เป็นออปชันแนล — คุณรับรองว่าออบเจ็กต์ที่ถูกอ้างอิงจะมีอายุยืนกว่าออบเจ็กต์นี้

การเลือกใช้ weak หรือ unowned

| สถานการณ์ | การใช้งาน | |---|---| | ออบเจ็กต์ที่ถูกอ้างอิงอาจกลายเป็น nil | `weak` | | ออบเจ็กต์ที่ถูกอ้างอิงมีอายุยืนกว่าออบเจ็กต์นี้เสมอ | `unowned` | | ไม่แน่ใจ | `weak` (ปลอดภัยกว่า) |

การเข้าถึง unowned หลังยกเลิกการจัดสรร

```swift var customer: Customer? = Customer() var card = CreditCard(customer: customer!) customer = nil print(card.customer.name) // 💥 crash — unowned is dangling ``` อย่าเข้าถึง `unowned` หลังจากออบเจ็กต์ที่ถูกอ้างอิงถูกยกเลิกการจัดสรรแล้ว

[weak self] ในคลอสเชอร์

```swift class VC { func load() { api.fetch { [weak self] data in guard let self else { return } self.render(data) } } } ``` `[weak self]` เป็นวิธีแก้ไขวงจรการเก็บรักษาที่พบบ่อยที่สุดใน Swift

[unowned self] ในคลอสเชอร์

```swift class Session { var onComplete: (() -> Void)? init() { onComplete = { [unowned self] in // self always outlives closure self.finish() } } } ``` ใช้ `[unowned self]` เฉพาะเมื่อแน่ใจว่า `self` จะไม่เป็น nil ขณะที่คลอสเชอร์ทำงาน

การเปลี่ยนค่าที่สังเกตเป็นศูนย์

```swift class Timer { weak var delegate: TimerDelegate? } var d: TimerDelegate? = ConcreteDelegate() let t = Timer() t.delegate = d d = nil print(t.delegate) // nil — automatically zeroed ```

แนวปฏิบัติที่ดีสำหรับรูปแบบตัวมอบหมาย

ประกาศคุณสมบัติตัวมอบหมายเป็น `weak` เสมอ: ```swift protocol MyDelegate: AnyObject { func didUpdate() } class MyView { weak var delegate: MyDelegate? } ``` ข้อจำกัด `AnyObject` จำเป็นต่อการใช้ `weak` กับโพรโทคอล

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

ประเภทการอ้างอิงใดจะถูกตั้งค่าเป็น `nil` โดยอัตโนมัติเมื่อออบเจ็กต์ที่ถูกอ้างอิงถูกยกเลิกการจัดสรร

สรุปทบทวน

ประเด็นสำคัญ: • `weak` — เป็นออปชันแนล เปลี่ยนเป็นศูนย์โดยอัตโนมัติ และปลอดภัย • `unowned` — ไม่เป็นออปชันแนล รับรองว่าออบเจ็กต์มีอายุยืนกว่า และทำให้โปรแกรมหยุดทำงานหากสมมติฐานไม่ถูกต้อง • รูปแบบตัวมอบหมาย: ใช้ `weak var delegate: Protocol?` พร้อมข้อจำกัด `AnyObject` เสมอ • คลอสเชอร์: `[weak self]` เป็นรูปแบบมาตรฐาน ให้ใช้ `guard let self` ภายใน • หากไม่แน่ใจ ให้เลือก `weak` แทน `unowned` ถัดไป: รายการจับค่าของคลอสเชอร์

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

บทเรียน “การอ้างอิงแบบ weak และ unowned” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การอ้างอิงแบบ weak และ unowned”

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

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

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

บทเรียน “การอ้างอิงแบบ weak และ unowned” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ARC นับจำนวนการอ้างอิงอย่างไร
  2. วงจรการคงอ้างอิง: สาเหตุและการตรวจหา
  3. การอ้างอิงแบบ weak และ unowned
  4. รายการจับค่าของโคลสเชอร์และ [weak self]
← กลับไปที่ Swift Academy