25.11.2024

Aulas 132: Wrappers de Propriedade Personalizados

No Swift, os wrappers de propriedade são um recurso poderoso que permite definir comportamentos personalizados para as propriedades em suas classes e structs. Eles oferecem uma maneira limpa e reutilizável de encapsular a lógica que pode ser aplicada a várias propriedades. Esta aula irá guiá-lo na criação e utilização de seus próprios wrappers de propriedade personalizados.

O que é um Wrapper de Propriedade?

Um wrapper de propriedade é uma struct, classe ou enum que encapsula como um valor é armazenado e manipulado. Você define uma lógica personalizada dentro do wrapper de propriedade que é aplicada automaticamente sempre que você acessa ou modifica o valor da propriedade.

Definindo um Wrapper de Propriedade

Para definir um wrapper de propriedade, você usa o atributo @propertyWrapper. Abaixo está um exemplo simples de um wrapper de propriedade que garante que um valor inteiro seja sempre positivo.

@propertyWrapper
struct Positivo {
    private var valor: Int

    var wrappedValue: Int {
        get { valor }
        set { valor = max(0, newValue) }
    }

    init(wrappedValue: Int) {
        self.valor = max(0, wrappedValue)
    }
}

Usando um Wrapper de Propriedade

Você pode usar o wrapper de propriedade Positivo em suas estruturas ou classes da seguinte maneira:

struct Conta {
    @Positivo var saldo: Int

    init(saldo: Int) {
        self.saldo = saldo
    }
}

var conta = Conta(saldo: 100)
print(conta.saldo) // Saída: 100

conta.saldo = -50
print(conta.saldo) // Saída: 0

Neste exemplo, sempre que tentamos definir a propriedade saldo para um valor negativo, o wrapper de propriedade garante que ele permaneça zero ou maior.

Exemplo Avançado: Observando Mudanças com Wrappers de Propriedade

Wrappers de propriedade também podem ser usados para observar mudanças. Aqui está um exemplo que imprime uma mensagem sempre que o valor muda.

@propertyWrapper
struct Notificando<Value> {
    private var valor: Value
    private let callback: (Value) -> Void

    var wrappedValue: Value {
        get { valor }
        set {
            valor = newValue
            callback(newValue)
        }
    }

    init(wrappedValue: Value, onChange: @escaping (Value) -> Void) {
        self.valor = wrappedValue
        self.callback = onChange
    }
}

Agora, vamos demonstrar como você pode usar o wrapper de propriedade Notificando:

struct Usuario {
    @Notificando(onChange: { novoValor in
        print("Nome alterado para \(novoValor)")
    }) var nome: String

    init(nome: String) {
        self.nome = nome
    }
}

var usuario = Usuario(nome: "Alice")
usuario.nome = "Bob" // Saída: Nome alterado para Bob

Neste exemplo, o wrapper Notificando permite especificar uma closure que é chamada toda vez que a propriedade nome muda, facilitando a adição de lógica de notificação.

Conclusão

Wrappers de propriedade personalizados no Swift permitem encapsular o comportamento da propriedade de maneira limpa e reutilizável. Se você deseja impor restrições, realizar ações quando os valores mudam ou encapsular lógica complexa, os wrappers de propriedade oferecem uma solução concisa. À medida que você cria aplicações mais complexas, encontrará os wrappers de propriedade inestimáveis para manter um código limpo e organizado.

Experimente criar seus próprios wrappers de propriedade e veja como eles podem simplificar seu código e melhorar a funcionalidade!

Video

Navigation