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

ตัวทำลายและวงจรชีวิตหน่วยความจำ

ใช้ deinit เพื่อล้างทรัพยากรก่อนที่อ็อบเจ็กต์จะถูกคืนหน่วยความจำ

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

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

คลาสของ Swift สามารถกำหนด `deinit` ซึ่งจะทำงานก่อนที่อินสแตนซ์จะถูกคืนหน่วยความจำเพียงเล็กน้อย การเข้าใจวงจรชีวิตอ็อบเจ็กต์ทั้งหมด — init → use → deinit — เป็นกุญแจสำคัญในการจัดการทรัพยากร

deinit คืออะไร

```swift class FileHandle { let path: String init(path: String) { self.path = path; print("Opened \(path)") } deinit { print("Closed \(path)") } } do { let f = FileHandle(path: "/tmp/log.txt") } // deinit called here when f goes out of scope ```

กฎไวยากรณ์ของ deinit

• ใช้ได้เฉพาะคลาสเท่านั้น — struct และ enum ไม่มี `deinit` • ไม่มีพารามิเตอร์หรือค่าที่คืนกลับ • ไม่มีวงเล็บ: `deinit { }` ไม่ใช่ `deinit() { }` • ARC เรียกใช้อัตโนมัติ — ห้ามเรียกด้วยตนเอง • `deinit` ของคลาสแม่จะถูกเรียกโดยอัตโนมัติหลัง `deinit` ของคลาสย่อย

กรณีการใช้งานสำหรับการล้างข้อมูล

การใช้งานทั่วไปของ `deinit`: • ปิดการเชื่อมต่อเครือข่าย • นำตัวสังเกตการณ์การแจ้งเตือนออก: `NotificationCenter.default.removeObserver(self)` • ทำให้ตัวจับเวลาหยุดทำงาน • ปิดตัวจัดการไฟล์หรือการเชื่อมต่อฐานข้อมูล

จำนวนการอ้างอิงและวงจรชีวิต

ARC ติดตามจำนวนการอ้างอิงแบบ strong ที่ชี้ไปยังอ็อบเจ็กต์: ```swift var a: Dog? = Dog() // retain count = 1 var b = a // retain count = 2 a = nil // retain count = 1 b = nil // retain count = 0 → deinit called ```

ห่วงโซ่ deinit ของคลาสย่อย

```swift class Base { deinit { print("Base deinit") } } class Child: Base { deinit { print("Child deinit") } // super.deinit called automatically after } var c: Child? = Child() c = nil // prints: Child deinit, then Base deinit ```

weak ป้องกันการเก็บอ้างอิง

```swift class Owner { var pet: Dog? deinit { print("Owner gone") } } class Dog { weak var owner: Owner? // weak = no strong retain deinit { print("Dog gone") } } ``` เมื่อกำหนด `owner` เป็น nil แล้ว `Owner` จะถูกคืนหน่วยความจำได้ แม้ว่า `Dog` จะเก็บการอ้างอิงไว้

วงจรการเก็บอ้างอิงป้องกัน deinit

```swift class A { var b: B? } class B { var a: A? } var a: A? = A() var b: B? = B() a?.b = b b?.a = a a = nil b = nil // deinit never called — retain cycle! ```

รูปแบบการยกเลิกตัวจับเวลา

```swift class PollingService { var timer: Timer? func start() { timer = Timer.scheduledTimer(...) } deinit { timer?.invalidate() timer = nil print("Timer stopped") } } ```

การตรวจหารอยรั่วด้วย Instruments

หากไม่เคยเรียก `deinit` มีโอกาสสูงว่าคุณมีวงจรการเก็บอ้างอิง ใช้ Xcode Instruments → แม่แบบ Leaks เพื่อตรวจหาอ็อบเจ็กต์ที่ถูกจัดสรรหน่วยความจำแต่ไม่เคยถูกคืนหน่วยความจำ

ตรวจสอบความเข้าใจ

ชนิดใดบ้างที่สามารถกำหนด `deinit` ได้

สรุปทบทวน

ประเด็นสำคัญ: • `deinit { }` — ล้างทรัพยากรก่อนคืนหน่วยความจำ • ใช้ได้เฉพาะคลาสเท่านั้น โดย `deinit` ของคลาสแม่จะถูกเรียกโดยอัตโนมัติหลังคลาสย่อย • ARC กำหนดเวลาที่ deinit จะทำงาน (เมื่อจำนวนการอ้างอิงลดลงเหลือ 0) • วงจรการเก็บอ้างอิงป้องกัน deinit — แก้ไขได้ด้วย `weak`/`unowned` • ใช้ Instruments Leaks เพื่อค้นหาอ็อบเจ็กต์ที่ deinit ไม่เคยทำงาน จบหลักสูตรแล้ว! ถัดไป: รูปแบบ enum และเครื่องจักรสถานะ

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

บทเรียน “ตัวทำลายและวงจรชีวิตหน่วยความจำ” ฟรีหรือไม่

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

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

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

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

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

บทเรียน “ตัวทำลายและวงจรชีวิตหน่วยความจำ” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การสืบทอดคลาสและคีย์เวิร์ด super
  2. override, final และการป้องกันการสร้างคลาสย่อย
  3. การแปลงชนิด: is, as?, as! และ as
  4. ตัวทำลายและวงจรชีวิตหน่วยความจำ
← กลับไปที่ Swift Academy