พื้นฐาน ARC: strong / weak / unowned
เรียนรู้การนับจำนวนการอ้างอิงของ ARC และเวลาที่ควรใช้ strong , weak และ unowned เพื่อหลีกเลี่ยงหน่วยความจำรั่ว
พื้นฐาน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- พื้นฐาน ARC: strong / weak / unowned
- วงจรการอ้างอิงและการแก้ด้วย weak/unowned
- ชนิดค่าเพื่อลดการใช้ข้อมูลร่วมกัน