0Pricing
Swift Academy · Lección

Listas de captura de closures y [weak self]

Utilice listas de captura para evitar que las closures capturen objetos con referencias fuertes.

Listas de captura de closures y [weak self] es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 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

Los closures capturan variables de su ámbito circundante. Las listas de captura (`[weak self]`, `[unowned self]`, `[value]`) controlan exactamente cómo se realizan esas capturas.

Captura strong predeterminada

```swift var name = "Alice" let greet = { print("Hello, \(name)") } name = "Bob" greet() // "Hello, Bob" — closure sees current value ``` De forma predeterminada, los closures capturan *referencias* a las variables.

Conceptos básicos de las listas de captura

```swift var count = 10 let snapshot = { [count] in print(count) } // captures value count = 99 snapshot() // 10 — snapshot of count at capture time ``` Incluir un tipo de valor en `[]` copia el valor en el momento en que se crea el closure.

Patrón [weak self]

```swift class API { func fetch(completion: @escaping () -> Void) { ... } } class VC { func load() { api.fetch { [weak self] in guard let self else { return } // self might be nil by now self.updateUI() } } } ```

guard let self con tiempo de vida ampliado

Swift 5.3 y versiones posteriores: vuelva a enlazar `self` dentro de `guard` sin crear un shadowing: ```swift { [weak self] in guard let self else { return } // 'self' is now strong within this block doA() doB() doC() } ```

Cuándo es seguro usar [unowned self]

```swift button.addTarget(self, action: #selector(tap), for: .touchUpInside) // If the button's closure is guaranteed not to outlive self: let action: () -> Void = { [unowned self] in self.handleTap() } ```

Capturar varios valores

```swift let base = 100 let multiplier = 2 let compute = { [base, multiplier] in base * multiplier } print(compute()) // 200 ``` Capture varios valores en la misma lista, separados por comas.

Lista de captura con enlaces con nombre

```swift let myService = service // rename in capture list: let handler = { [service = myService] in service.process() } ``` Es útil para capturar una instantánea específica con un nombre nuevo.

Escaping frente a non-escaping

• Un closure `@escaping` puede almacenarse y llamarse después de que la función devuelva el control → existe riesgo de ciclos • Un closure non-escaping se llama antes de que la función devuelva el control → no hay riesgo de ciclos ```swift func apply(_ f: () -> Void) { f() } // non-escaping, no [weak] needed func later(_ f: @escaping () -> Void) { queue.async { f() } } // escaping ```

Depurar problemas de captura

Si sospecha que existe un ciclo: 1. Añada `deinit { print("deallocated") }` a la clase 2. Navegue fuera de la pantalla o establezca la instancia en nil 3. Si deinit no imprime nada → existe un ciclo Después, añada `[weak self]` a los closures de esa clase.

Comprobación rápida

¿Qué hace `[weak self]` en una lista de captura?

Resumen

Puntos clave: • Los closures capturan referencias de forma predeterminada • La lista de captura `[value]` copia los tipos de valor en el momento de la creación • `[weak self]`: no retiene, se convierte automáticamente en nil; use `guard let self` • `[unowned self]`: no retiene y no es segura frente a nil • Los closures `@escaping` necesitan listas de captura; los non-escaping normalmente no ¡Curso completado! Siguiente tema: programación funcional en Swift.

Preguntas frecuentes

¿La lección «Listas de captura de closures y [weak self]» es gratis?

Sí — el texto completo de «Listas de captura de closures y [weak self]» 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 «Listas de captura de closures y [weak self]»?

Utilice listas de captura para evitar que las closures capturen objetos con referencias fuertes. 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 4 de 4.

¿Cuánto tiempo toma la lección «Listas de captura de closures y [weak self]»?

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

  1. Cómo ARC cuenta las referencias
  2. Ciclos de retención: causas y detección
  3. Referencias weak y unowned
  4. Listas de captura de closures y [weak self]
← Volver a Swift Academy