Swift Academy · Lección

Grafos mixtos de valores y referencias

Comprenda las semánticas de referencia ocultas de los structs que contienen clases y aprenda a gestionarlas.

Grafos mixtos de valores y referencias es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Bienvenida

Las structs pueden contener clases como propiedades almacenadas. Cuando lo hacen, la struct se comporta externamente como un tipo valor, pero comparte internamente la referencia a la clase: una trampa sutil.

Struct que contiene una clase

```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! ```

Solo se copian las propiedades valor

Cuando se copia una struct: • Las propiedades de tipo valor (`label: String`) se copian por completo • En las propiedades de tipo referencia (`storage: Storage`), solo se copia el puntero Esto se denomina *shallow copy*.

Creación de una copia profunda

```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 al rescate

Las colecciones propias de Swift evitan este problema mediante 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) } } ```

Clases que contienen structs

```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 ```

Identidad frente a igualdad

```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 ```

Struct recursiva mediante una clase

Las structs no pueden referenciarse a sí mismas, pero pueden contener una clase que haga referencia a la struct: ```swift struct Tree { var value: Int var children: [Tree] // OK — Array uses class internally } ```

Detección del uso compartido inesperado

Use `isKnownUniquelyReferenced` durante la ejecución para detectar el uso compartido: ```swift var s = Storage() var r: AnyObject = s print(isKnownUniquelyReferenced(&s)) // true var s2 = s print(isKnownUniquelyReferenced(&s)) // false — shared ```

Directrices de diseño

Cuando una struct debe contener estado mutable de tipo referencia: 1. Implemente COW para recuperar la semántica de valor 2. O use una clase inmutable: `let` frente a `var` para la propiedad de la clase 3. O rediseñe la solución; quizá la struct debería ser una clase Documente claramente cuándo el uso compartido es intencional.

Comprobación rápida

Cuando copia una struct que contiene una propiedad de clase, ¿qué sucede con la clase?

Resumen

Conclusiones clave: • La copia de una struct es superficial: las referencias a clases se comparten • `isKnownUniquelyReferenced` detecta el uso compartido durante la ejecución • Implemente COW para recuperar una verdadera semántica de valor • `===` / `!==` comprueban la identidad de los objetos en las clases • Las estructuras recursivas usan Array (respaldado internamente por una clase) como colección de hijos Siguiente: diseño de API con semántica de valor.

Preguntas frecuentes

¿La lección «Grafos mixtos de valores y referencias» es gratis?

Sí — el texto completo de «Grafos mixtos de valores y referencias» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Grafos mixtos de valores y referencias»?

Comprenda las semánticas de referencia ocultas de los structs que contienen clases y aprenda a gestionarlas. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Grafos mixtos de valores y referencias»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Stack frente a heap: dónde viven los valores
Mutación, compartición y aliasing inesperado
Grafos mixtos de valores y referencias
Diseño de APIs con semántica de valor

← Volver a Swift Academy