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

Question

What is the difference between let and var in Apple\'s Swift language?

In my understanding, it is a compiled language but it does not check

Answer 1

Everyone has pretty much answered this but here's a way you can remember what's what

Let will always say the same think of "let" as let this work for once and always as for "var" variable's can always change hence them being called variable's

Answer 2

It's maybe better to state this difference by the Mutability / Immutability notion that is the correct paradigm of values and instances changeability in Objects space which is larger than the only "constant / variable" usual notions. And furthermore this is closer to Objective C approach.

2 data types: value type and reference type.

In the context of Value Types:

'let' defines a constant value (immutable). 'var' defines a changeable value (mutable).

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

In the context of Reference Types:

The label of a data is not the value but the reference to a value.

if aPerson = Person(name:Foo, first:Bar)

aPerson doesn't contain the Data of this person but the reference to the data of this Person.

let aPerson = Person(name:Foo, first:Bar)
               //< data of aPerson are changeable, not the reference

var aPerson = Person(name:Foo, first:Bar)
               //< both reference and data are changeable.

eg:

var aPersonA = Person(name:A, first: a)
var aPersonB = Person(name:B, first: b)

aPersonA = aPersonB

aPersonA now refers to Person(name:B, first: b)

and

let aPersonA = Person(name:A, first: a)
let aPersonB = Person(name:B, first: b)

let aPersonA = aPersonB // won't compile

but

let aPersonA = Person(name:A, first: a)

aPersonA.name = "B" // will compile

Answer 3

let defines a "constant". Its value is set once and only once, though not necessarily when you declare it. For example, you use let to define a property in a class that must be set during initialization:

class Person {

    let firstName: String
    let lastName: String

    init(first: String, last: String) {
         firstName = first
         lastName = last
         super.init()
    }
}

With this setup, it's invalid to assign to firstName or lastName after calling (e.g.) Person(first:"Malcolm", last:"Reynolds") to create a Person instance.

You must define a type for all variables (let or var) at compile time, and any code that attempts to set a variable may only use that type (or a subtype). You can assign a value at run time, but its type must be known at compile time.

Answer 4

let is a constant value, so it can never be changed.

let number = 5  
number = 6               //This will not compile.

Var is a variable, and can change (but after it is defined not to a different data type.)

var number = 5
number = 6               //This will compile.

If you try changing the variable to a different dataType, it will not work

var number = 5
number = "Hello World"   //This will not compile.

Answer 5

Source: https://thenucleargeeks.com/2019/04/10/swift-let-vs-var/

When you declare a variable with var, it means it can be updated, it is variable, it’s value can be modified.

When you declare a variable with let, it means it cannot be updated, it is non variable, it’s value cannot be modified.

var a = 1 
print (a) // output 1
a = 2
print (a) // output 2

let b = 4
print (b) // output 4
b = 5 // error "Cannot assign to value: 'b' is a 'let' constant"

Let us understand above example: We have created a new variable “a” with “var keyword” and assigned the value “1”. When I print “a” I get output as 1. Then I assign 2 to “var a” i.e I’m modifying value of variable “a”. I can do it without getting compiler error because I declared it as var.

In the second scenario I created a new variable “b” with “let keyword” and assigned the value “4”. When I print “b” I got 4 as output. Then I try to assign 5 to “let b” i.e. I’m trying to modify the “let” variable and I get compile time error “Cannot assign to value: ‘b’ is a ‘let’ constant”.

Answer 6

Like Luc-Oliver, NullData, and a few others have said here, let defines immutable data while var defines mutable data. Any func that can be called on the variable that is marked mutating can only be called if it is a var variable (compiler will throw error). This also applies to func's that take in an inout variable.

However, let and var also mean that the variable cannot be reassigned. It has two meanings, both with very similar purposes