Valor projetado em wrappers de propriedade

Feb 24 2023
Se você é novo no Swift's Property Wrappers, eu o encorajo a ler a primeira parte deste artigo. Ele explica o que são wrappers de propriedade e sua propriedade Wrapped Value.

Se você é novo no Swift's Property Wrappers, eu o encorajo a ler a primeira parte deste artigo . Ele explica o que são wrappers de propriedade e sua propriedade Wrapped Value.

O que é um valor projetado em wrappers de propriedade?

Os wrappers de propriedade podem adicionar outra propriedade especial diferente do valor agrupado, chamado de valor projetado. O Valor Projetado como o nome indica, permite projetar o valor envolvido em outro valor .

Exemplo:

Suponha que temos uma estrutura chamada Person que inclui uma propriedade de string chamada email, que contém o endereço de e-mail da pessoa:

struct Person {
  let name: String
  let email: String
}

struct Person {
    let name: String
    let email: String

    func isValidEmail() -> Bool {
        let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let emailPred = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
        return emailPred.evaluate(with: email)
    }
}

let person = Person(name: "Alex", email: "[email protected]")
person.isValidEmail()

Implementação:

Para implementar o valor projetado com wrappers de propriedade, podemos criar um wrapper que usa uma string como um email, e o valor projetado retornará verdadeiro ou falso com base no email de valor agrupado. Para adicionar o valor projetado ao Property Wrapper, algumas condições devem ser atendidas:

  1. O valor projetado deve ser nomeado comoprojectedValue.
  2. Ele pode retornar qualquer tipo.
  3. Ele deve estar no mesmo nível de acesso que o valor agrupado.

@propertyWrapper
struct Email {
  var wrappedValue: String
  var projectedValue: Bool {
    let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
    let emailPred = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
    return emailPred.evaluate(with: wrappedValue)
  }
}

struct Person {
    let name: String
    @Email var email: String
}

Acessar um valor projetado em wrappers de propriedade?

Para acessar o valor projetado do Property Wrapper, precisamos colocar um $ (cifrão) antes do nome da propriedade. Por exemplo, em nossa Personstruct com o @Emailwrapper da propriedade, para verificar se o e-mail é válido ou não, podemos chamar o valor projetado assim: `$email

Exemplo 2:

Outro bom exemplo de onde usamos um valor projetado é a formatação de uma data para texto. Digamos que temos uma estrutura Student que contém a propriedade birthDate como Date.

struct Student {
    var name: String
    var birthDate: Date
}

func dateToString(_ date: Date) -> String {
  let formatter = DateFormatter()
  formatter.dateFormat = "MM-dd-YYYY"
  return formatter.string(from: wrappedValue)
}

@propertyWrapper struct USDate {
    var wrappedValue: Date
    var projectedValue: String {
        let formatter = DateFormatter()
        formatter.dateFormat = "MM-dd-YYYY"
        return formatter.string(from: wrappedValue)
    }
}

struct Person {
    var name: String
    @USDate var birthDate: Date
}
let me = Person(name: "Stewart", birthDate: Date())

print(me.birthDate) // prints current date
print(me.$birthDate) // prints current date like this "02-11-2023"

Os wrappers de propriedade são um recurso semelhante ao idioma que não faz parte do idioma principal, semelhante aos operadores personalizados. Os operadores nos permitem escrever operadores personalizados e eles parecem fazer parte da linguagem principal, mas, na verdade, nós os criamos.

Ao usar wrappers de propriedade, podemos reduzir a redundância e simplificar o código, tornando-o mais compreensível.

Obrigado por ler!

Fique ligado para a próxima parte……