Swift Academy · Aula

Criação de um wrapper de propriedade personalizado

Implemente @propertyWrapper com wrappedValue para encapsular lógica.

Criação de um wrapper de propriedade personalizado é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Boas-vindas

Os invólucros de propriedades encapsulam a lógica de armazenamento de propriedades, permitindo reutilizar código repetitivo, como validação, transformação ou persistência.

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

O requisito de wrappedValue

Todo invólucro de propriedades deve definir `wrappedValue`. É isso que o usuário do invólucro lê e grava.

Invólucros de propriedades 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 } } ```

Usando o invólucro

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

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

Invólucro em uma propriedade armazenada versus calculada

Os invólucros de propriedades adicionam armazenamento oculto (`_wrappedValue`). A propriedade anotada é açúcar sintático: ```swift @Clamped var level = 50 // Desugars to: var _level = Clamped(wrappedValue: 50) var level: Int { get { _level.wrappedValue } set { _level.wrappedValue = newValue } } ```

Invólucro para 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 ```

Invólucro seguro para execução concorrente

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

Combinando invólucros em um tipo

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

Verificação rápida

Qual é a propriedade obrigatória em todo tipo `@propertyWrapper`?

Recapitulação

Principais conclusões: • `@propertyWrapper` + `wrappedValue` = invólucro de propriedades mínimo • O invólucro adiciona armazenamento oculto `_name` • Os invólucros genéricos funcionam com qualquer tipo T • Usos comuns: limitação de valores, registro, UserDefaults e segurança em execução concorrente • Argumentos personalizados do inicializador permitem configuração Próximo: valores projetados.

Perguntas Frequentes

A aula “Criação de um wrapper de propriedade personalizado” é grátis?

Sim — o texto completo de “Criação de um wrapper de propriedade personalizado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Criação de um wrapper de propriedade personalizado”?

Implemente @propertyWrapper com wrappedValue para encapsular lógica. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Criação de um wrapper de propriedade personalizado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Criação de um wrapper de propriedade personalizado
Valores projetados com $binding
@Published e observação no Combine
Composição de vários wrappers de propriedade

← Voltar para Swift Academy