@Property/@Synthesize Equivalent in Swift

@property/@synthesize equivalent in swift

Swift provides no differentiation between properties and instance variables (i.e, the underlying store for a property). To define a property, you simply declare a variable in the context of a class.

A swift class is simply a ClassName.swift file.

You declare a class and properties as

class SomeClass {

  var topSpeed: Double
  var aStrProperty: String
  var anIntProperty: Int

  //Initializers and other functions

}

You access property values via dot notation. As of Xcode6 beta 4, there also are access modifiers (public, internal and private) in Swift. By default every property is internal. See here for more information.

For more information, refer to the Swift Programming Guide:

Stored Properties and Instance Variables

If you have experience with Objective-C, you may know that it provides
two ways to store values and references as part of a class instance.
In addition to properties, you can use instance variables as a backing
store for the values stored in a property.

Swift unifies these concepts into a single property declaration. A
Swift property does not have a corresponding instance variable, and
the backing store for a property is not accessed directly. This
approach avoids confusion about how the value is accessed in different
contexts and simplifies the property’s declaration into a single,
definitive statement. All information about the property—including its
name, type, and memory management characteristics—is defined in a
single location as part of the type’s definition.

@property @synthesize equivalent in swift

There is no equivalent.

In Swift when you write a varor let in a class or struct declaration you already declaring a property.

Define properties to store values

This is what is written in Swift documentation.
If you are concerned about access control you can use private or public modifiers.

public var somePublicVariable = 0

If you'd like to override properties such as you did in Objective-C you will find useful properties observers such as didSet{} willSet{}.

If you need a a readonly properties you can make the setter private.

public private(set) var hours = 0

@property @synthesize equivalent in swift

There is no equivalent.

In Swift when you write a varor let in a class or struct declaration you already declaring a property.

Define properties to store values

This is what is written in Swift documentation.
If you are concerned about access control you can use private or public modifiers.

public var somePublicVariable = 0

If you'd like to override properties such as you did in Objective-C you will find useful properties observers such as didSet{} willSet{}.

If you need a a readonly properties you can make the setter private.

public private(set) var hours = 0

@synthesize vs @dynamic, what are the differences?

@synthesize will generate getter and setter methods for your property.
@dynamic just tells the compiler that the getter and setter methods are implemented not by the class itself but somewhere else (like the superclass or will be provided at runtime).

Uses for @dynamic are e.g. with subclasses of NSManagedObject (CoreData) or when you want to create an outlet for a property defined by a superclass that was not defined as an outlet.

@dynamic also can be used to delegate the responsibility of implementing the accessors. If you implement the accessors yourself within the class then you normally do not use @dynamic.

Super class:

@property (nonatomic, retain) NSButton *someButton;
...
@synthesize someButton;

Subclass:

@property (nonatomic, retain) IBOutlet NSButton *someButton;
...
@dynamic someButton;

Is there a way to override property setters and getters in Swift?

While researching this question, I actually happened upon my answer, but still figured it should be put here for anyone else with the same question.

---

Yes, according to the Swift Programming Language documentation's page on Properties, getters and setters can be made in a similar way to how C# tackles the problem:

struct MyParentType {
    var myPlainVar: MyType = MyType()
    
    var myCustomGetterVar: MyType {
        // do more stuff
        return self.myCustomGetterVar
    }
    
    var myCustomGetterSetterVar: MyType {
        get {
            // do more stuff
            return self.myCustomGetterSetterVar
        }
        set {
            // do stuff
            self.myCustomGetterSetterVar = newValue
            // do more stuff
        }
    }
    
    var myCustomFancyVar: MyType? {
        willSet {
            // do stuff with newValue
        }
        // actual setting is done automatically, so no set{}
        didSet {
            // do more stuff with oldValue
        }
    }
}

Note that variables with didSet must be initialized or optional, and cannot have a get, since properties which are computed with get can easily implement their own didSet and willSet if they so choose.

Do properties implicitly create a class member of that name and type?

Yes, it's implicitly created with the @sythesize keyword if an ivar of the specified name doesn't already exist. For example, given the above properies:

@synthesize name; // Creates an instance variable called "name"

Alternatively...

@synthesize name = _name; // Creates an instance variable called "_name"

Which means you no longer need to specify ivars in your class' @interface.

Custom setter for @property?

@property (getter=yourGetter,setter=yourSetter:) UIButton *but;

Custom setter for @property?

@property (getter=yourGetter,setter=yourSetter:) UIButton *but;

---

Related Topics