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

กราฟที่มีทั้งค่าและการอ้างอิง

ทำความเข้าใจความหมายของการอ้างอิงที่ซ่อนอยู่เมื่อโครงสร้างมีคลาส และวิธีจัดการ

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

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

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

สตรักต์ที่มีคลาส

```swift class Storage { var data: [Int] = [] } struct Container { var storage = Storage() var label: String = "" } var a = Container() var b = a // copies label, but SHARES storage! a.storage.data.append(1) print(b.storage.data) // [1] — shared! ```

มีเพียงคุณสมบัติประเภทค่าเท่านั้นที่ถูกคัดลอก

เมื่อมีการคัดลอกสตรักต์: • คุณสมบัติประเภทค่า (`label: String`) จะถูกคัดลอกทั้งหมด • คุณสมบัติประเภทอ้างอิง (`storage: Storage`) — จะคัดลอกเฉพาะตัวชี้เท่านั้น สิ่งนี้เรียกว่า *สำเนาแบบตื้น*

การสร้างสำเนาแบบลึก

```swift struct Container { var storage: Storage func deepCopy() -> Container { let newStorage = Storage() newStorage.data = storage.data // copy values return Container(storage: newStorage, label: label) } } ```

COW ช่วยแก้ปัญหา

คอลเลกชันของ Swift เองหลีกเลี่ยงปัญหานี้ด้วยการใช้ COW: ```swift struct SafeContainer { private(set) var storage = Storage() mutating func append(_ n: Int) { if !isKnownUniquelyReferenced(&storage) { storage = storage.copy() // copy before mutating } storage.data.append(n) } } ```

คลาสที่มีสตรักต์

```swift class ViewModel { var point = CGPoint(x: 0, y: 0) // value type inside reference type } let vm1 = ViewModel() let vm2 = vm1 // same ViewModel! vm1.point.x = 5 print(vm2.point.x) // 5 — shared because ViewModel is a class ```

เอกลักษณ์เทียบกับความเท่ากัน

```swift class Dog { var name: String = "" } let x = Dog() let y = x print(x === y) // true — same object print(x !== y) // false let z = Dog() print(x === z) // false — different objects ```

สตรักต์แบบวนซ้ำผ่านคลาส

สตรักต์ไม่สามารถอ้างอิงตัวเองได้โดยตรง แต่สามารถมีคลาสที่อ้างอิงถึงสตรักต์ได้: ```swift struct Tree { var value: Int var children: [Tree] // OK — Array uses class internally } ```

การตรวจจับการใช้งานร่วมที่ไม่คาดคิด

ใช้ `isKnownUniquelyReferenced` ขณะทำงานเพื่อตรวจจับการใช้งานร่วม: ```swift var s = Storage() var r: AnyObject = s print(isKnownUniquelyReferenced(&s)) // true var s2 = s print(isKnownUniquelyReferenced(&s)) // false — shared ```

แนวทางการออกแบบ

เมื่อสตรักต์จำเป็นต้องเก็บสถานะประเภทอ้างอิงที่เปลี่ยนแปลงได้: 1. ใช้ COW เพื่อคืนคุณสมบัติความหมายแบบค่า 2. หรือใช้คลาสที่ไม่เปลี่ยนแปลง โดยเลือก `let` หรือ `var` สำหรับคุณสมบัติของคลาส 3. หรือออกแบบใหม่ — บางทีสตรักต์ควรเป็นคลาส โปรดบันทึกให้ชัดเจนเมื่อการใช้งานร่วมกันเป็นสิ่งที่ตั้งใจ

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

เมื่อคัดลอกสตรักต์ที่มีคุณสมบัติเป็นคลาส คลาสนั้นจะเกิดอะไรขึ้น

สรุปทบทวน

ประเด็นสำคัญ: • การคัดลอกสตรักต์เป็นการคัดลอกแบบตื้น — การอ้างอิงไปยังคลาสจะยังใช้ร่วมกัน • `isKnownUniquelyReferenced` ตรวจจับการใช้งานร่วมขณะทำงานได้ • ใช้ COW เพื่อคืนคุณสมบัติความหมายแบบค่าที่แท้จริง • `===` / `!==` ใช้ทดสอบเอกลักษณ์ของวัตถุสำหรับคลาส • โครงสร้างแบบวนซ้ำใช้ Array ซึ่งมีคลาสอยู่เบื้องหลังเป็นรายการลูก ถัดไป: การออกแบบ API สำหรับความหมายแบบค่า

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

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

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

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

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

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

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

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

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

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

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

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

  1. สแตกกับฮีป: ค่าต่าง ๆ อยู่ที่ใด
  2. การเปลี่ยนแปลง การใช้ร่วมกัน และการอ้างชื่อที่ไม่คาดคิด
  3. กราฟที่มีทั้งค่าและการอ้างอิง
  4. การออกแบบ API ตามความหมายของค่า
← กลับไปที่ Swift Academy