What is the use of "static" keyword if "let" keyword used to define constants/immutables in swift?

I will break them down for you:

var : used to create a variable

let : used to create a constant

static : used to create type properties with either let or var. These are shared between all objects of a class.

Now you can combine to get the desired out come:

static let key = "API_KEY" : type property that is constant

static var cnt = 0 : type property that is a variable

let id = 0 : constant (can be assigned only once, but can be assigned at run time)

var price = 0 : variable

So to sum everything up var and let define mutability while static and lack of define scope. You might use static var to keep track of how many instances you have created, while you might want to use just varfor a price that is different from object to object. Hope this clears things up a bit.

Example Code:

class MyClass{
    static let typeProperty = "API_KEY"
    static var instancesOfMyClass = 0
    var price = 9.99
    let id = 5

}

let obj = MyClass()
obj.price // 9.99
obj.id // 5

MyClass.typeProperty // "API_KEY"
MyClass.instancesOfMyClass // 0

A static variable is shared through all instances of a class. Throw this example in playground:

class Vehicle {
    var car = "Lexus"
    static var suv = "Jeep"
}

// changing nonstatic variable
Vehicle().car // Lexus
Vehicle().car = "Mercedes"
Vehicle().car // Lexus

// changing static variable
Vehicle.suv // Jeep
Vehicle.suv = "Hummer"
Vehicle.suv // Hummer

When you change the variable for the static property, that property is now changed in all future instances.

Static Variables are belong to a type rather than to instance of class. You can access the static variable by using the full name of the type.

Code:

class IOS {

  var iosStoredTypeProperty = "iOS Developer"

  static var swiftStoredTypeProperty = "Swift Developer"

 }

 //Access the iosStoredTypeProperty by way of creating instance of IOS Class

let iOSObj = IOS()

print(iOSObj.iosStoredTypeProperty)  // iOS Developer


 //print(iOSObj.swiftStoredTypeProperty) 
 //Xcode shows the error 
 //"static member 'swiftStoredTypeProperty' cannot be used on instance of type IOS”


 //You can access the static property by using full name of the type
print(IOS.swiftStoredTypeProperty)  // Swift Developer

Hope this helps you..

to see the difference between type properties and / or methods and class properties and / or methods, please look at this self explanatory example from apple docs

class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107
    }
}

Static properties may only be declared on type, not globally. In other words static property === type property in Swift. To declare type property you have to use static keyword.

"The let keyword defines a constant" is confusing for beginners who are coming from C# background (like me). In C# terms, you can think of "let" as "readonly" variable.

(answer to How exactly does the “let” keyword work in Swift?)

Use both static and let to define constant

public static let pi = 3.1416            // swift

public const double pi = 3.1416;         // C#
public static final double pi = 3.1416   // Java     

Whenever I use let to define constant, it feels like I am using readonly of C#. So, I use both static and let to define constant in swift.

Let me explain it for those who need Objective-C reference.

Hope you all remember that we were using a constant file in our Objective-C project to keep all the static API keys like below.

/ In your *.m file
static NSString * const kNSStringConst = @"const value";

Here the keyword Static does not mean that the kNSStringConst is a constant, it just defines that the kNSStringConst can be accessed globally. They keyword const makes it constant.

Now let's move to Swift.

In Swift, Static let and Static var are considered as Type Properties, which means that they can be accessed by their type.

For Example:

class World {
   static let largestPopulation = "China"
   static var secondLargestPopulation = "India"
}

World.largestPopulation = "German"   // Cannot assign to property: 'largestPopulation' is a 'let' constant
World.secondLargestPopulation = "UK"
World.secondLargestPopulation // UK

In this example, two properties have static keyword, one is constant and another one is variable.

As you can see, the constant Static let declared can be accessed by it's type, but cannot be changed. The Static var declared can not only be accessed by it's type but also can be modified. Consequently, all the future instances will be changed.

[Swift's property]
[var vs let]
[class vs static]

In a nutshell class and static are type property and belongs to Type in a single copy