Criando wrappers, projectedValue
Crie um wrapper personalizado, configure wrappedValue e disponibilize metadados/auxiliares com projectedValue ( $ ).
Criando wrappers, projectedValue é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.
Por que usar envoltórios de propriedades?
Um envoltório de propriedade é um tipo reutilizável que gerencia como uma propriedade é armazenada e lida:
- wrappedValue: o valor público
- projectedValue: API adicional por meio de
$ - Configuração por meio de inicializadores/argumentos
Clamped + sinalizador projetado
@Clamped limita um número a um intervalo. O projectedValue ($hp) indica se a última atribuição foi limitada.
@propertyWrapper
struct Clamped {
private var value: Int
private let range: ClosedRange<Int>
private(set) var wasClampedLastSet = false
var wrappedValue: Int {
get { value }
set {
let clamped = min(max(newValue, range.lowerBound), range.upperBound)
wasClampedLastSet = (clamped != newValue)
value = clamped
}
}
var projectedValue: Bool { wasClampedLastSet } // $prop -> was it clamped?
init(wrappedValue: Int, range: ClosedRange<Int>) {
self.range = range
let clamped = min(max(wrappedValue, range.lowerBound), range.upperBound)
self.value = clamped
self.wasClampedLastSet = (clamped != wrappedValue)
}
}
struct Player {
@Clamped(range: 0...100) var hp: Int = 120 // init clamps to 100
}
var p = Player()
print(p.hp) // 100
p.hp = -5
print(p.hp, p.$hp) // 0 true (was clamped)Normalizar e exibição alternativa
Os envoltórios podem transformar a entrada (aparar/converter para minúsculas). $property pode expor uma forma alternativa prática.
@propertyWrapper
struct Normalized {
private var storage: String = ""
var wrappedValue: String {
get { storage }
set { storage = newValue.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() }
}
var projectedValue: String { storage.uppercased() } // alternate view
init(wrappedValue: String) { self.wrappedValue = wrappedValue }
}
struct User {
@Normalized var username: String = " Alice "
}
let u = User()
print(u.username) // "alice"
print(u.$username) // "ALICE" (projected)Envoltório configurável
Passe argumentos aos envoltórios (por exemplo, comprimento). O envoltório aplica a formatação sempre que você define a propriedade.
@propertyWrapper
struct Padded {
private var value: String
private let length: Int
var wrappedValue: String {
get { value }
set {
let s = newValue
value = s.count >= length ? String(s.prefix(length))
: s + String(repeating: " ", count: length - s.count)
}
}
var projectedValue: Int { value.count } // current width
init(wrappedValue: String, length: Int) {
self.length = length
self.value = ""
self.wrappedValue = wrappedValue
}
}
struct Row {
@Padded(length: 6) var code: String = "AB"
}
var r = Row()
print("|\(r.code)|") // |AB |
print(r.$code) // 6Histórico via $value
Use projectedValue para expor metadados, como um histórico de alterações, sem sobrecarregar a API do valor principal.
@propertyWrapper
struct History<Value> {
private var value: Value
private(set) var changes: [Value] = []
var wrappedValue: Value {
get { value }
set { changes.append(value); value = newValue }
}
var projectedValue: [Value] { changes } // $prop -> previous values
init(wrappedValue: Value) { self.value = wrappedValue }
}
struct Settings {
@History var level: Int = 1
}
var s = Settings()
s.level = 2
s.level = 3
print(s.level) // 3
print(s.$level) // [1, 2]Orientações de projeto
Dicas:
- Mantenha os envoltórios pequenos e focados.
- Documente o que $projectedValue expõe.
- Prefira transformações puras; evite efeitos colaterais pesados.
- Forneça inicializadores claros e valores padrão sensatos.
Finalidade do valor projetado
Verificação rápida: Para que $property é usado em envoltórios?
Recapitulação
Recapitulação: Implemente @propertyWrapper com um wrappedValue; exponha auxiliares/sinalizadores/histórico por meio de projectedValue ($) e configure o comportamento por meio de inicializadores.
Perguntas Frequentes
A aula “Criando wrappers, projectedValue” é grátis?
Sim — o texto completo de “Criando wrappers, projectedValue” é 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 3 aulas no total.
O que vou aprender em “Criando wrappers, projectedValue”?
Crie um wrapper personalizado, configure wrappedValue e disponibilize metadados/auxiliares com projectedValue ( $ ). 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 3.
Quanto tempo leva a aula “Criando wrappers, projectedValue”?
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
- Criando wrappers, projectedValue
- Reutilização e restrições
- Padrões comuns de wrappers (validação, armazenamento em cache)