Propiedades Lazy en Programación: Uso y Ventajas
Clase 6 de 27 • Curso de Programación Orientada a Objetos en Swift
Contenido del curso
Tipos de Propiedades
- 5

Propiedades Almacenadas en Swift: Uso y Ejemplos Prácticos
04:48 min - 6

Propiedades Lazy en Programación: Uso y Ventajas
Viendo ahora - 7

Propiedades Computadas en Swift: Uso y Ejemplos Prácticos
10:30 min - 8

Computed properties de solo lectura en Swift
05:14 min - 9

Observers en Swift: willSet y didSet
07:18 min - 10

Variables estáticas en clases, estructuras y enumerados
09:19 min
Métodos, subíndices y herencia
- 11

Métodos de instancia en Swift con self
07:35 min - 12

Métodos Mutantes en Estructuras y Enumerados en Swift
09:05 min - 13

Métodos de clase en Swift: static vs class
10:50 min - 14

Subíndices en Swift: Sintaxis y Aplicaciones Prácticas
09:01 min - 15

Manipulación de Matrices y Subíndices en Programación
12:27 min - 16

Herencia de Clases en Programación Orientada a Objetos
10:14 min - 17

Sobrescritura de Métodos y Propiedades en Clases Derivadas
12:11 min
Inicializadores o constructores
- 18

Inicializadores en Sweet: Creación y Uso Efectivo de Constructores
06:50 min - 19

Modificación de Constructores y Parámetros Opcionales en Swift
10:10 min - 20

Constructores Designados y de Conveniencia en Herencia de Clases
09:37 min - 21

Constructores y manejo de inicialización opcional en Swift
08:42 min - 22

Destructores en Programación: Liberación de Recursos Automática
07:12 min
Encadenamiento opcional
Conclusión
Optimiza memoria y rendimiento con lazy properties: inicializan su valor solo cuando el código realmente lo necesita. Así evitas cargar objetos pesados por adelantado y reduces el coste de arranque de tus estructuras y clases, manteniendo propiedades sin uso fuera de memoria hasta el primer acceso.
¿Qué es una lazy property y por qué importa?
Las lazy stored properties son propiedades cuyo valor no se crea en la inicialización del objeto, sino en el momento del primer uso. Esto es clave cuando algunas propiedades quizá nunca se usen o cuando su creación sea costosa.
- Se declara anteponiendo la palabra lazy a una stored property.
- No se inicializa hasta que se accede por primera vez en código.
- Reduce consumo de memoria si la propiedad es pesada.
- Evita trabajo innecesario cuando la propiedad no se utiliza.
¿Cómo implementarla en un caso real con un data importer?
Imagina una clase encargada de importar datos de un fichero externo: un data importer con un filename (por ejemplo, "data.txt"). Un data manager orquesta distintos importadores (local, nube, peer to peer, etc.) y guarda los datos en un array de strings. Aquí conviene que el importador sea lazy porque puede ser muy pesado (conexiones, buffers, hosts, conversiones), mientras que un array vacío apenas ocupa memoria.
class DataImporter {
var filename = "data.txt"
// ... funcionalidad de importación
}
class DataManager {
lazy var importer = DataImporter() // Se crea al primer uso.
var data: [String] = [] // Liviana: no necesita ser lazy.
}
let manager = DataManager()
manager.data.append("Elemento 1")
manager.data.append("Elemento 2")
// Hasta aquí, 'importer' no se ha creado.
_ = manager.importer.filename // Primer acceso: aquí se crea 'importer'.
¿Qué ocurre antes y después del primer acceso?
Antes de pedirle nada al importador, el data manager funciona con normalidad: puedes leer y añadir a data sin que el importer exista en memoria. En el instante en que accedes a una propiedad del importador (por ejemplo, su filename), el sistema reserva memoria, crea el objeto y ya queda disponible.
- Data accesible desde el inicio:
manager.datafunciona sin crear el importador. - Importador diferido:
manager.importerno existe hasta el primer acceso efectivo. - Primer acceso significativo: al consultar
manager.importer.filename, se crea y usa "data.txt". - Estado previo: al inspeccionarlo antes del acceso, el importador aparece como nil (no inicializado) aunque esté declarado.
¿Cuándo conviene usarla y cuándo no?
Usa lazy cuando una propiedad pueda ser costosa o rara vez utilizada. Evítala en propiedades livianas y triviales.
- Úsala si la propiedad es una clase pesada: múltiples métodos, muchas propiedades, buffers, hosts, descargas y conversiones.
- Úsala si el objeto puede no usarse nunca: ahorra memoria hasta que sea necesario.
- No la uses en propiedades ligeras: por ejemplo, un array de strings vacío apenas ocupa memoria.
- Beneficio clave: la propiedad permanece en nil y fuera de memoria hasta requerirse, creando el objeto justo a tiempo.
¿Te gustaría compartir un caso donde aplicarías una lazy property o tienes dudas sobre su primer uso? Comenta tu escenario y lo revisamos juntos.