Swift Academy · Lección

Referencias weak y unowned

Aprenda a elegir entre weak (Optional) y unowned (no Optional) para romper ciclos.

Referencias weak y unowned 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.

Introducción

Para romper los ciclos de retención se necesitan referencias que no incrementen el contador de ARC. Swift proporciona dos: `weak` (opcional y convertido automáticamente en nil) y `unowned` (no opcional e inseguro si es nil).

Referencias weak

```swift class Owner { var pet: Pet? } class Pet { weak var owner: Owner? } // does not retain var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p p?.owner = o o = nil // Owner deinit — p.owner becomes nil automatically ```

weak siempre es opcional

```swift class View { weak var delegate: ViewDelegate? } ``` `weak` debe ser `var` y opcional: Swift lo convierte automáticamente en nil cuando se desasigna el objeto referenciado.

Referencias unowned

```swift class Customer { var card: CreditCard? } class CreditCard { unowned let customer: Customer // card always has a customer init(customer: Customer) { self.customer = customer } } ``` `unowned` no mantiene la referencia y no es opcional: usted garantiza que el objeto referenciado vivirá más tiempo que este objeto.

Elegir entre weak y unowned

| Situación | Usar | |---|---| | El objeto referenciado puede convertirse en nil | `weak` | | El objeto referenciado siempre vivirá más que este objeto | `unowned` | | No está seguro | `weak` (más seguro) |

Acceder a unowned después de la desasignación

```swift var customer: Customer? = Customer() var card = CreditCard(customer: customer!) customer = nil print(card.customer.name) // 💥 crash — unowned is dangling ``` Nunca acceda a `unowned` después de que se haya desasignado el objeto referenciado.

[weak self] en closures

```swift class VC { func load() { api.fetch { [weak self] data in guard let self else { return } self.render(data) } } } ``` `[weak self]` es la solución más habitual para los ciclos de retención en Swift.

[unowned self] en closures

```swift class Session { var onComplete: (() -> Void)? init() { onComplete = { [unowned self] in // self always outlives closure self.finish() } } } ``` Use `[unowned self]` únicamente cuando tenga la certeza de que `self` no será nil cuando se ejecute el closure.

Puesta automática en nil

```swift class Timer { weak var delegate: TimerDelegate? } var d: TimerDelegate? = ConcreteDelegate() let t = Timer() t.delegate = d d = nil print(t.delegate) // nil — automatically zeroed ```

Práctica recomendada para el patrón delegate

Declare siempre las propiedades delegate como `weak`: ```swift protocol MyDelegate: AnyObject { func didUpdate() } class MyView { weak var delegate: MyDelegate? } ``` La restricción `AnyObject` es necesaria para usar `weak` con protocolos.

Comprobación rápida

¿Qué tipo de referencia se establece automáticamente en `nil` cuando se desasigna el objeto referenciado?

Resumen

Puntos clave: • `weak`: opcional, se convierte automáticamente en nil y es seguro • `unowned`: no opcional, se garantiza que el objeto referenciado vivirá más tiempo; falla si esa garantía no se cumple • Patrones delegate: use siempre `weak var delegate: Protocol?` con la restricción `AnyObject` • Closures: `[weak self]` es el patrón estándar; use `guard let self` en su interior • En caso de duda, elija `weak` en lugar de `unowned` Siguiente tema: listas de captura de closures.

Preguntas frecuentes

¿La lección «Referencias weak y unowned» es gratis?

Sí — el texto completo de «Referencias weak y unowned» 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 «Referencias weak y unowned»?

Aprenda a elegir entre weak (Optional) y unowned (no Optional) para romper ciclos. 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 «Referencias weak y unowned»?

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

Cómo ARC cuenta las referencias
Ciclos de retención: causas y detección
Referencias weak y unowned
Listas de captura de closures y [weak self]

← Volver a Swift Academy