Variables and Constants in Swift

If you want to become an iOS Developer, understanding variables and constants in Swift is one of the first steps you need to take. Every application stores, processes, and displays information, from a user’s name to a product price or the current temperature. In Swift, variables and constants allow you to store this information and use it throughout your code.

Swift is Apple’s programming language for building applications for iPhone, iPad, Mac, Apple Watch, and other Apple platforms. Whether you are developing an application with SwiftUI or working with another Apple framework, knowing when to use var and let is essential.

In this tutorial, you will learn what variables and constants are, how to declare them, and when to use each one in your projects.

What Is a Variable in Swift?

A variable is a named container that stores a value that can change while your program runs. For example, a game might use a variable to track a player’s score, or a shopping application might store the number of items in a cart.

In Swift, you declare a variable using the var keyword.

Here is a simple example:

var playerName = "Alex"
var score = 10

score = 20

print(playerName)
print(score)

In this example, playerName stores the text “Alex”, while score stores the number 10. Later, the value of scorechanges to 20.

The var keyword tells Swift that the value associated with this variable can be reassigned.

You can use variables for information that changes over time, such as a user’s current location, a download’s progress, or the selected item in an application.

How to Declare a Variable Using var

Declaring a variable in Swift is straightforward. Start with var, write the variable’s name, and assign it a value using the equals sign.

The general syntax is:

var variableName = value

For example:

var age = 25
var city = "London"
var isLoggedIn = false

age = 26
city = "Manchester"
isLoggedIn = true

Swift automatically infers the type of each value. In this example, age is an integer, city is a string, and isLoggedIn is a Boolean.

You can also specify a type explicitly:

var temperature: Double = 22.5
var username: String = "developer"

Understanding how to declare variables is a fundamental skill for anyone learning Swift in Xcode, Apple’s integrated development environment.

What Is a Constant in Swift?

A constant is a named value that cannot be reassigned after it has been initialized. Constants are useful when information should remain fixed throughout the relevant part of your program.

In Swift, you declare a constant using the let keyword.

For example:

let appName = "Weather App"
let maximumAttempts = 3
let country = "United Kingdom"

print(appName)
print(maximumAttempts)
print(country)

These values can be read and used wherever they are accessible, but you cannot assign them new values.

For example, the following code produces a compiler error:

let maximumAttempts = 3

maximumAttempts = 5 // Error

Swift prevents this reassignment because maximumAttempts was declared with let.

Constants are particularly useful for fixed configuration values, mathematical values, and information that should not be accidentally modified.

The Difference Between var and let

The main difference between var and let is whether a value can be reassigned.

Consider this example:

var currentScore = 100
currentScore = 150

let gameTitle = "Space Adventure"
// gameTitle = "New Adventure" // Error

The score changes because it is declared with var. The game title cannot be reassigned because it is declared with let.

As a general rule, use let whenever you do not need to reassign a value. Choose var when reassignment is necessary.

This approach makes your code easier to understand and reduces the risk of unintended changes.

Using Variables and Constants in SwiftUI

When developing interfaces with SwiftUI, you will frequently work with values that control what appears on the screen.

For example:

import SwiftUI

struct ContentView: View {
    let appTitle = "My First App"
    var username = "Alex"

    var body: some View {
        VStack {
            Text(appTitle)
            Text("Welcome, \(username)!")
        }
        .padding()
    }
}

Here, appTitle is a constant, while username is a variable. Both values are displayed using SwiftUI’s Text view.

However, changing a regular stored property does not automatically update a SwiftUI interface. For interactive state, you will commonly use property wrappers such as @State:

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("Count: \(count)")

            Button("Increase") {
                count += 1
            }
        }
        .padding()
    }
}

The count property uses var because its value changes whenever the button is pressed. The @State property wrapper allows SwiftUI to update the interface when that state changes.

Best Practices for Every iOS Developer

When writing code in Xcode, follow these simple recommendations:

• Use let by default when a value does not need to be reassigned.
• Use var when a value must change.
• Choose descriptive names, such as userAge or totalPrice.
• Specify types explicitly when doing so improves clarity.
• Use @State in SwiftUI when a view needs to manage changing local state.

Conclusion

Understanding variables and constants in Swift is essential for building reliable Apple applications. The var keyword declares values that can be reassigned, while let declares values that cannot be reassigned after initialization.

By learning when to use each keyword, practicing in Xcode, and applying these concepts in SwiftUI, you can develop cleaner, safer, and more maintainable code. For every aspiring iOS Developer, mastering these fundamentals is an important first step toward building professional applications.