Swift Academy · Lección

Creación de un property wrapper personalizado

Implemente @propertyWrapper con wrappedValue para encapsular lógica.

Creación de un property wrapper personalizado es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 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

Los property wrappers encapsulan la lógica de almacenamiento de las propiedades, lo que permite reutilizar código repetitivo como validación, transformación o persistencia.

Sintaxis básica

```swift @propertyWrapper struct Clamped { var wrappedValue: Int { didSet { wrappedValue = min(max(0,wrappedValue),100) } } init(wrappedValue: Int) { self.wrappedValue = min(max(0,wrappedValue),100) } } struct Gauge { @Clamped var level = 50 } var g = Gauge() g.level = 150 // clamped to 100 ```

El requisito de wrappedValue

Todo property wrapper debe definir `wrappedValue`. Es el valor que el código que utiliza el wrapper lee y escribe.

Property wrappers genéricos

```swift @propertyWrapper struct Logged { private var value: T var wrappedValue: T { get { print("get"); return value } set { print("set to \(newValue)"); value = newValue } } init(wrappedValue: T) { value = wrappedValue } } ```

Uso del wrapper

```swift struct Model { @Logged var name: String = "Default" } var m = Model() let n = m.name // prints "get" m.name = "Alice" // prints "set to Alice" ```

Argumentos personalizados del inicializador

```swift @propertyWrapper struct Default { var wrappedValue: T init(wrappedValue: T) { self.wrappedValue = wrappedValue } init(_ default: T) { wrappedValue = default } } @Default(42) var count: Int ```

Wrapper en una propiedad almacenada frente a una calculada

Los property wrappers añaden almacenamiento oculto (`_wrappedValue`). La propiedad anotada es azúcar sintáctico: ```swift @Clamped var level = 50 // Desugars to: var _level = Clamped(wrappedValue: 50) var level: Int { get { _level.wrappedValue } set { _level.wrappedValue = newValue } } ```

Wrapper de UserDefaults

```swift @propertyWrapper struct UserDefault { let key: String; let defaultValue: T var wrappedValue: T { get { UserDefaults.standard.object(forKey: key) as? T ?? defaultValue } set { UserDefaults.standard.set(newValue, forKey: key) } } } @UserDefault(key:"theme",defaultValue:"light") var theme: String ```

Wrapper seguro para subprocesos

```swift @propertyWrapper final class Atomic { private var value: T; private let lock = NSLock() var wrappedValue: T { get { lock.lock(); defer { lock.unlock() }; return value } set { lock.lock(); defer { lock.unlock() }; value = newValue } } init(wrappedValue: T) { value = wrappedValue } } ```

Combinar wrappers en un tipo

```swift struct Settings { @Clamped var volume = 50 @UserDefault(key:"username",defaultValue:"") var username: String @Logged var debugMode = false } ```

Comprobación rápida

¿Cuál es la propiedad obligatoria en todo tipo `@propertyWrapper`?

Repaso

Puntos clave: • `@propertyWrapper` + `wrappedValue` = property wrapper mínimo • El wrapper añade almacenamiento oculto `_name` • Los wrappers genéricos funcionan con cualquier tipo T • Usos habituales: limitar valores, registrar eventos, UserDefaults y seguridad de subprocesos • Los argumentos personalizados del inicializador permiten configurar el wrapper Siguiente tema: valores proyectados

Preguntas frecuentes

¿La lección «Creación de un property wrapper personalizado» es gratis?

Sí — el texto completo de «Creación de un property wrapper personalizado» 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 «Creación de un property wrapper personalizado»?

Implemente @propertyWrapper con wrappedValue para encapsular lógica. 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 1 de 4.

¿Cuánto tiempo toma la lección «Creación de un property wrapper personalizado»?

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

Creación de un property wrapper personalizado
Valores proyectados con $binding
@Published y observación en Combine
Composición de varios property wrappers

← Volver a Swift Academy