Property Wrappers and Property Observers

 Q. Explain the difference between property wrappers and property observers in Swift.

Property Wrappers and Property Observers:

Property wrappers and property observers are both features in Swift that relate to properties, but they serve different purposes and operate at different levels of abstraction.

Property Observers:

1. Purpose:
   • Property observers are used to observe and respond to changes in the value of a property.
2. Keywords:
   • willSet: Called just before the value of the property is about to be set.
   • didSet: Called immediately after the new value is set.
3. Scope:
   • Property observers are applied directly to the properties they observe.
4. Example:

var counter: Int = 0 {
    willSet {
        print("About to set counter to \(newValue)")
    }

    didSet {
        print("Counter was set to \(counter) (previously \(oldValue))")
    }
}

5. Use Cases:

• Commonly used for executing code when a property is about to change (willSet) or has just changed (didSet).
• Useful for tasks like updating UI elements, logging, or maintaining consistency between related properties.

Property Wrappers:

1. Purpose:
   • Property wrappers allow you to encapsulate the logic for property behaviors, such as validation, transformation, or lazy initialization.
2. Keywords:
   • The @propertyWrapper attribute is used to define a property wrapper. The properties that use the wrapper are annotated with @wrapperName.
3. Scope:
   • Property wrappers are created as separate structures or classes and applied to properties using the @ symbol.
4. Example:

@propertyWrapper
struct Trimmed {
   private(set) var value: String = ""

    init(wrappedValue: String) {
        self.value = wrappedValue.trimmingCharacters(in: .whitespacesAndNewlines)
    }
       
      var wrappedValue: String {
        get { value }
       set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
    }
}

struct User {
    @Trimmed var username: String
}

5. Use Cases:

• • Useful for abstracting away complex property logic into a reusable component.
  • Can simplify property declaration by separating concerns and promoting code reusability.

Summary:

• Property Observers are primarily concerned with reacting to changes in property values, providing a way to execute code before (willSet) or after (didSet) a property is updated.
• Property Wrappers are about encapsulating property logic. They allow you to define reusable components that can be applied to properties, providing a clean and modular way to handle common property behaviors.

In some cases, you might use property observers within a property wrapper to perform additional actions when the wrapped value changes. The choice between them depends on the specific requirements of the property you’re dealing with.