Differences between “static var” and “var” in Swif

Question

What is the main difference between "static var" and "var" in Swift? Can someone explain this difference to me, possibly with a little example?

Answer 1

I'll give you a very nice Swifty example based on this post. Though this is a bit more sophisticated.

Imagine you have a project in which you have 15 collectionViews in your app. For each you have to set the cellIdentifier & nibName. Do you really want to rewrite all code for your that 15 times?

There is a very POP solution to your problem:

Let's help ourselves by writing a protocol which returns a string version of our ClassName

protocol ReusableView: class {
    static var defaultReuseIdentifier: String { get }
}

extension ReusableView where Self: UIView {
    static var defaultReuseIdentifier: String {
        return String(Self)
    }
}
extension BookCell : ReusableView{
}

The same for the nibName of each custom cell you have created:

protocol NibLoadableView: class {
    static var nibName: String { get }
}

extension NibLoadableView where Self: UIView {
    static var nibName: String {
        return String(Self)
    }
}

extension BookCell: NibLoadableView {
}

so now where ever I need nibName I would just do

BookCell.nibName

And where ever I need cellIdentifier I would just do:

BookCell.defaultReuseIdentifier

Now specifically to your question. Do you think we need to change the cellIdentifier per each new instance of BookCell?! No! All cells of BookCell will have the same identifier. It's not something that would change per instance. As a result it's been made static

While I did answer your question, the solution to reducing the number of lines for the 15 collectionViews can still be significantly improved so do see the blog post linked.

---

That blog post has actually been turned into a video by NatashaTheRobot

Answer 2

A static var is property variable on a struct versus an instance of the struct. Note that static var can exist for an enum too.

Example:

struct MyStruct {
    static var foo:Int = 0
    var bar:Int
}

println("MyStruct.foo = \(MyStruct.foo)") // Prints out 0

MyStruct.foo = 10

println("MyStruct.foo = \(MyStruct.foo)") // Prints out 10

var myStructInstance = MyStruct(bar:12)

// bar is not 
// println("MyStruct.bar = \(MyStruct.bar)")

println("myStructInstance = \(myStructInstance.bar)") // Prints out 12

Notice the difference? bar is defined on an instance of the struct. Whereas foo is defined on the struct itself.

Answer 3

static var belongs to type itself while var belongs to instance (specific value that is of specific type) of type. For example:

struct Car {
    static var numberOfWheels = 4
    var plateNumber: String
}

Car.numberOfWheels = 3
let myCar = Car(plateNumber: "123456")

All cars has same amount of wheels. An you change it on type Car itself.

In order to change plate number you need to have instance of Car. For example, myCar.