Swift Academy · บทเรียน

พื้นฐาน ARC: strong / weak / unowned

เรียนรู้การนับจำนวนการอ้างอิงของ ARC และเวลาที่ควรใช้ strong , weak และ unowned เพื่อหลีกเลี่ยงหน่วยความจำรั่ว

บทเรียน 1 จาก 38 ขั้นตอน

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

ARC ภายในหนึ่งนาที

Swift ใช้ ARC (การนับจำนวนการอ้างอิงอัตโนมัติ) การอ้างอิงแต่ละรายการแบบ เข้มแข็ง จะเพิ่มจำนวนการอ้างอิงของอินสแตนซ์คลาส เมื่อจำนวนลดลงเหลือศูนย์ deinit จะทำงานและหน่วยความจำจะถูกคืน

เข้มแข็งเป็นค่าเริ่มต้น

การอ้างอิงแบบเข้มแข็งเป็นค่าเริ่มต้น เมื่อการอ้างอิงแบบเข้มแข็งรายการสุดท้ายหายไป deinit จะถูกเรียกใช้

final class Person {
    let name: String
    init(_ name: String) { self.name = name; print("init:", name) }
    deinit { print("deinit:", name) }
}

var p: Person? = Person("Ada")
p = nil  // ARC count -> 0, triggers deinit

ตัวอย่างวงจร

การอ้างอิงแบบ เข้มแข็งสองทางจะสร้าง วงจรการอ้างอิง ARC จึงไม่สามารถคืนหน่วยความจำให้ได้ ทำให้เกิดการรั่วไหลของหน่วยความจำ

final class A {
    var b: B?
    deinit { print("A deinit") }
}
final class B {
    var a: A?
    deinit { print("B deinit") }
}

var a: A? = A()
var b: B? = B()
a?.b = b      // strong
b?.a = a      // strong

a = nil       // no deinit (cycle)
b = nil       // still no deinit (leak)

การอ้างอิงแบบอ่อน

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

final class A2 {
    weak var b: B2?   // weak breaks the strong cycle
    deinit { print("A2 deinit") }
}
final class B2 {
    var a: A2?
    deinit { print("B2 deinit") }
}

var a2: A2? = A2()
var b2: B2? = B2()
a2?.b = b2   // weak
b2?.a = a2   // strong

a2 = nil     // A2 deinit runs
b2 = nil     // B2 deinit runs

การอ้างอิงแบบไม่เป็นเจ้าของ

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

final class Customer {
    let name: String
    var card: CreditCard?
    init(_ name: String) { self.name = name }
    deinit { print("Customer deinit") }
}
final class CreditCard {
    unowned let owner: Customer   // never optional; owner must outlive card
    init(owner: Customer) { self.owner = owner }
    deinit { print("CreditCard deinit") }
}

var cust: Customer? = Customer("Lars")
cust!.card = CreditCard(owner: cust!)
cust = nil  // deallocates both (no cycle)

เคล็ดลับและรูปแบบการใช้งาน

เคล็ดลับ:

  • ให้การอ้างอิงเป็น แบบเข้มแข็งเป็นค่าเริ่มต้น
  • ตัดวงจรด้วย แบบอ่อน (ตัวแทนมักใช้การอ้างอิงแบบอ่อน)
  • ใช้ แบบไม่เป็นเจ้าของเฉพาะเมื่อรับประกันอายุการใช้งานได้เท่านั้น (เช่น ลูก → แม่)
  • คลาสเป็นชนิดอ้างอิง ส่วนโครงสร้าง/ชนิดแจกแจงไม่จำเป็นต้องใช้กฎของ ARC

แบบอ่อนเทียบกับแบบไม่เป็นเจ้าของ

ตรวจสอบสั้น ๆ: ควรเลือก แบบอ่อน หรือ แบบไม่เป็นเจ้าของ เมื่อใด

สรุป

สรุป: ARC จะคืนหน่วยความจำให้อ็อบเจกต์เมื่อไม่มีการอ้างอิงแบบ เข้มแข็งเหลืออยู่ ป้องกันวงจรด้วย แบบอ่อน (เป็นค่าทางเลือก) หรือ แบบไม่เป็นเจ้าของ (รับประกันอายุการใช้งาน) เลือกรูปแบบการเป็นเจ้าของที่ปลอดภัยและจำเป็นน้อยที่สุด

เริ่มต้นได้ฟรี

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

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

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

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

บทเรียน “พื้นฐาน ARC: strong / weak / unowned” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “พื้นฐาน ARC: strong / weak / unowned”

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

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

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

บทเรียน “พื้นฐาน ARC: strong / weak / unowned” ใช้เวลานานแค่ไหน

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

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

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

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

  1. พื้นฐาน ARC: strong / weak / unowned
  2. วงจรการอ้างอิงและการแก้ด้วย weak/unowned
  3. ชนิดค่าเพื่อลดการใช้ข้อมูลร่วมกัน
← กลับไปที่ Swift Academy