What is the real difference between let and var in swift?

The first and the usual answer is: The let is immutable, the var is mutable

Here's a breakdown of the key differences between let and var, grouped by aspects:

• Usage

• Performance

• Safety and threaing

Usage

let used like a constant while var is values that may change it’s value. The compiler also helps you if you don’t change the value but you declared your variable as var and you will get a swift lint warning.

Definition

When you define a new variable in case of var your freedom is higher:

• let is immutable var is mutable. In case of primitive type it is a constant. However if an object is created with let it’s values can be modifies depends on it’s definition.

public class objTest {
    var x: Int
    let y: Int

    init(x: Int, y: Int) {
        self.x = x
        self.y = y
     }
}

// usage
let o1 = objTest(x: 3, y: 4)
o1.y = 6 // won’t work
o1.x = 7 // you can do it as o1 is a reference type

• Contrary to the original assumption, let can be used with optionals. However, using let with an optional only makes sense if you're not planning to reassign the value. It's useful when you want to declare a constant that will be initialized once, possibly with a delayed assignment (e.g., during initialization), but not changed afterward.

• Computed properties can’t be let. However if a computed property not changes just make a very simply constant calculation, the property can be only var

  let answerToLife: Int { 6 * 7 } // logically ok, but you can’t do this

• let can’t be declared in convenience init as it’s value should be set in designated init.

Performance

Small optimization

When you create a variable and don’t change it’s value the Xcode will warn you that you should change it’s type. Maybe you can leave it as it is just a warning.

Why is this important if you just create it and access its value?

The compiler can optimaze memory and CPU usage better for values declared with let, since it guarantees immutability.

Yes it is a small thing, but a lot of small performace optimization can make a better quailty.

ARC

Yes there is difference in reference counting. What do you think what is the lifecycle of a variable in aspect of reference count?

• When you use let the reference count will decrease when the blocks ended what created it.

And what can do the var what the let can’t? Changes it’s value. And how can decrease it the refrence count?

• You can change the value of the var variable (if it is optional) to nil. (Yes it is also small thing, but a lot small think can be has a great affect.)

  For example when you create an object level variable you can initialize it and if you know when you don’t need it’s value, or you need to know it is missing, you can set it to nil. Imagin that you have an app what show a notification to user when the user start the app. You want to show it and make sure she / he will read it. The user taps on it. The messages will open and you can set the message notification to nil. When it is nil will kno you don’t have to show it. (The notification can be for example a small object what creates a bit coplex message with some info)

var notification: MessageNotification? = ...

// After showing it notification = nil
// drops the reference

• You can also can add a new object to the var. For example when you iterates in an array. When the var gets a new value the old object reference count will decrease

Safety and threading

let immutable therefore cannot cause a race condition. So never can be a situation when 2 or more streams tries to write it.

If you use a let to reach it’s value in a thread it is constant so it will always will show the same value. For example if you have a string for show a specific toast message for user you always will show the same message if you use let

var is mutable so if you want to reach it’s value in a thread it can also take a bad value. For example: The user taps on a button. You start a thread and in a thread you sets a flag with name isFetchStarted and you set it to true. After that you check if !isFetchStarted than you make something. If the user taps to the button quickly 2 or more thread can be started and can starts the fetch.