Understanding Swift Syntax, Variables, and Constants

Course: iOS App Development Training

Topic: Understanding Swift Syntax, Variables, and Constants

Course Link: iOS App Development Training at JustAcademy

Demo Link: Register for a Free Course Demo

Official Website: JustAcademy

1. Introduction to Swift

Swift is a modern, powerful, and type-safe programming language developed by Apple for building applications across Apple platforms, including iOS, iPadOS, macOS, watchOS, and tvOS. It is widely used for native iPhone and iPad application development with tools such as Xcode, SwiftUI, and UIKit.

Understanding Swift syntax, variables, and constants is one of the first steps toward becoming an iOS developer. These concepts help developers store information, perform calculations, manage application state, and display dynamic content.

For example, a shopping application may store a product name, price, available quantity, and whether the product is in stock. Swift variables and constants provide a structured way to represent this information.

Why Learn Swift?

• Develop native applications for Apple platforms.
• Write readable and expressive code.
• Use strong type checking to reduce programming errors.
• Manage application data through variables, constants, and data types.
• Build interactive interfaces using SwiftUI or UIKit.
• Prepare for advanced concepts such as functions, structures, classes, and optionals.

2. Learning Objectives

After completing this topic, learners should be able to:

• Understand the basic structure and syntax of Swift code.
• Differentiate between variables and constants.
• Declare values using var and let.
• Understand type inference and type annotations.
• Work with common Swift data types.
• Follow Swift naming conventions and coding practices.
• Use operators and string interpolation in basic programs.
• Identify common syntax and type-related errors.
• Write a simple Swift program suitable for an iOS development project.

3. Understanding Basic Swift Syntax

Syntax refers to the rules that define how code must be written in a programming language. Swift has a clean syntax designed to make code easy to read and maintain.

3.1 A Simple Swift Program

import Foundation

let appName = "My First iOS App"
var launchCount = 1

print(appName)
print(launchCount)

Explanation:

• import Foundation imports the Foundation framework, which provides common types and utilities.
• let appName = "My First iOS App" declares a constant containing text.
• var launchCount = 1 declares a variable containing an integer.
• print() displays information in the output console.

Output:

My First iOS App
1

3.2 Statements and Expressions

A statement performs an action or declares something in a program. An expression represents a value or a computation that produces a value.

let price = 250
let quantity = 3
let total = price * quantity

In this example, the declarations create constants, while price * quantity is an expression that calculates the total value.

3.3 Semicolons

Swift generally does not require semicolons at the end of statements when each statement appears on its own line.

let firstName = "Aarav"
let age = 22
print(firstName)
print(age)

Semicolons can separate multiple statements on the same line, but using separate lines is usually easier to read.

3.4 Comments in Swift

Comments explain code to developers. The compiler ignores ordinary comments when executing the program.

// This is a single-line comment.

let courseName = "iOS Development"

/*
 This is a multiline comment.
 It can explain a larger section of code.
*/

print(courseName)

Use comments to explain the reason behind a decision or clarify complex logic. Avoid comments that simply repeat what the code already makes obvious.

4. Variables in Swift

A variable is a named storage location whose value can change after it has been initialized. Swift uses the var keyword to declare a variable.

4.1 Declaring a Variable

var studentName = "Riya"
var studentAge = 21
var courseFee = 15000.0

print(studentName)
print(studentAge)
print(courseFee)

Here, Swift infers the types from the initial values. The name is a String, the age is an Int, and the fee is a Double.

4.2 Changing a Variable's Value

var score = 50
print(score)

score = 75
print(score)

score += 5
print(score)

Output:

50
75
80

The value of score changes as the program runs. The operator += adds a value to the existing value and assigns the result back to the variable.

4.3 When Should You Use Variables?

Use var when the stored value needs to change during the application's operation.

• A user's current score in a game.
• The number of items in a shopping cart.
• A countdown timer's remaining seconds.
• A form's temporary input value.
• The current page number in a multi-page interface.

Example:

var cartItemCount = 0

cartItemCount += 1
cartItemCount += 2

print("Items in cart: \(cartItemCount)")

Output:

Items in cart: 3

5. Constants in Swift

A constant is a named value that cannot be reassigned after it has been initialized. Swift uses the let keyword to declare a constant.

5.1 Declaring a Constant

let appTitle = "Fitness Tracker"
let maximumLoginAttempts = 5
let taxRate = 0.18

print(appTitle)
print(maximumLoginAttempts)
print(taxRate)

These values are declared using let because the program is not intended to reassign them.

5.2 Attempting to Change a Constant

let country = "India"
country = "Canada"

This code produces a compile-time error because a constant cannot be assigned a new value after initialization. To allow reassignment, declare the value with var instead.

5.3 When Should You Use Constants?

Use let whenever a name should refer to a value that does not need to be reassigned.

• The title of an application screen.
• A fixed maximum number of attempts.
• A product identifier that should remain unchanged within a scope.
• A value calculated once and then reused.
• A configuration value that is not expected to change during the relevant operation.

let productName = "Wireless Headphones"
let unitPrice = 1999.0
let quantity = 2

let totalPrice = unitPrice * Double(quantity)

print(productName)
print(totalPrice)

Declaring values with let helps communicate intent and prevents accidental reassignment.

6. Difference Between Variables and Constants

Important: A constant prevents reassignment of the name to a different value. For reference types such as class instances, this does not automatically make every property of the referenced object immutable.

7. Swift Data Types

A data type determines what kind of value a constant or variable can store and which operations are valid for that value. Swift checks types to catch many errors before a program runs.

7.1 Integer Values

The Int type represents whole numbers. It is commonly used for counts, indexes, and ages.

let numberOfStudents: Int = 30
var completedLessons: Int = 4

completedLessons += 1

print(numberOfStudents)
print(completedLessons)

7.2 Floating-Point Values

Swift commonly infers decimal numeric literals as Double. Use floating-point types for values that need a fractional component.

let productPrice: Double = 499.50
let discount: Double = 50.0
let finalPrice = productPrice - discount

print(finalPrice)

For financial applications, floating-point arithmetic may not be suitable for every monetary calculation because some decimal values cannot be represented exactly in binary floating-point. Consider a decimal or integer-in-smallest-units approach when exact currency arithmetic is required.

7.3 String Values

A String stores text, such as names, messages, addresses, and labels.

let firstName = "Ananya"
let lastName = "Sharma"

let fullName = firstName + " " + lastName

print(fullName)

7.4 Boolean Values

A Bool stores either true or false. It is useful for conditions, switches, validation results, and feature flags.

var isNotificationEnabled = true

isNotificationEnabled = false

print(isNotificationEnabled)

8. Type Inference in Swift

Type inference means the Swift compiler determines the type of a value from the information available in the declaration. When an initial value makes the type clear, you usually do not need to write the type explicitly.

let city = "Mumbai"       // String
let population = 1000000  // Int
let rating = 4.7          // Double
let isAvailable = true    // Bool

Swift infers the type from each initial value. The declared value remains strongly typed; type inference does not make it dynamically changeable to an unrelated type.

Benefits of Type Inference

• Reduces repetitive type declarations.
• Keeps simple code concise.
• Works with Swift's compile-time type checking.
• Improves readability when the type is obvious.

Example: Type Inference Error

var age = 25
age = 26       // Valid
// age = "26"  // Error: String cannot be assigned to Int

Although age is a variable, its inferred type is Int. A variable can change its value, but it cannot be reassigned a value of an incompatible type.

9. Type Annotations

A type annotation explicitly declares the expected type of a constant or variable. It is written by placing a colon after the name and then specifying the type.

var username: String = "riya123"
var age: Int = 22
var percentage: Double = 86.5
var isVerified: Bool = false

Type annotations are useful when a declaration does not have an initial value, when the intended type is not obvious, or when explicit type information improves clarity.

Declaring a Value Before Initializing It

var welcomeMessage: String
welcomeMessage = "Welcome to iOS Development!"

print(welcomeMessage)

The variable must receive a value before it is read. Swift's definite-initialization checks help prevent the use of uninitialized local values.

Type Annotation Versus Type Inference

10. Rules for Naming Variables and Constants

Good names make code easier to understand and maintain. Swift identifiers can contain letters, digits, and many Unicode characters, but they cannot begin with a digit or contain ordinary whitespace.

Recommended Naming Practices

• Use descriptive names such as studentName instead of x.
• Use lower camel case for variable and constant names, such as totalAmount.
• Start names with a letter or an allowed underscore.
• Do not use spaces in identifiers.
• Avoid reserved keywords as identifiers.
• Choose names that express the purpose of the value.

Valid and Invalid Examples

11. Operators Used with Variables and Constants

Operators perform calculations, comparisons, and logical operations on values.

11.1 Arithmetic Operators

let firstNumber = 20
let secondNumber = 6

print(firstNumber + secondNumber)
print(firstNumber - secondNumber)
print(firstNumber * secondNumber)
print(firstNumber / secondNumber)
print(firstNumber % secondNumber)

When both operands are integers, integer division discards the fractional part. In this example, 20 / 6 produces 3.

11.2 Comparison Operators

let age = 22

print(age == 22)
print(age != 18)
print(age > 18)
print(age < 30)
print(age >= 21)
print(age <= 25)

Comparison operators produce Boolean results, which can be used in conditions.

11.3 Compound Assignment Operators

var points = 10

points += 5
points -= 2
points *= 2

print(points)

Compound assignment operators update an existing variable. They cannot be used to reassign a constant.

12. String Interpolation

String interpolation inserts the value of a variable, constant, or expression into a string. In Swift, place the expression inside \(...).

let studentName = "Meera"
let marks = 92

print("Student: \(studentName)")
print("Marks: \(marks)")
print("Next score target: \(marks + 5)")

Output:

Student: Meera
Marks: 92
Next score target: 97

String interpolation is often more readable than combining many strings using the + operator.

13. Multiple Declarations

Swift allows related constants or variables to be declared on the same line, separated by commas. However, separate declarations may be clearer when values have different purposes.

let minimumAge = 18, maximumAge = 60
var red = 255, green = 120, blue = 50

print(minimumAge)
print(maximumAge)
print(red, green, blue)

Each name follows the same declaration rules, and each inferred type must be compatible with its assigned value.

14. Scope and Lifetime: An Introduction

Scope describes where a name can be accessed in code. A variable or constant declared inside a function or conditional block is generally local to that scope.

func displayMessage() {
    let message = "Hello, Swift!"
    print(message)
}

displayMessage()

// The local constant message is not accessible here.

Understanding scope becomes important when building iOS screens, writing functions, and managing data across views and objects.

15. Using Variables and Constants in iOS Apps

Variables and constants are used throughout native iOS development. Their roles depend on whether a value needs to be reassigned and how the application manages state.

Example: User Profile Information

let userName = "Aarav"
let userID = 1024
var isLoggedIn = false
var notificationCount = 0

isLoggedIn = true
notificationCount += 1

print("User: \(userName)")
print("ID: \(userID)")
print("Logged in: \(isLoggedIn)")
print("Notifications: \(notificationCount)")

In this example, the username and ID are constants within this example's scope, while the login flag and notification count are variables because their values change.

Example: SwiftUI View

The following example introduces how a constant string can be displayed in a SwiftUI interface. It assumes a SwiftUI project has been created in Xcode.

import SwiftUI

struct WelcomeView: View {
    let userName = "Aarav"

    var body: some View {
        VStack(spacing: 12) {
            Text("Welcome, \(userName)!")
                .font(.title)

            Text("Start learning Swift today.")
        }
        .padding()
    }
}

userName is a constant, and the body property describes the view's interface. In a complete app, the view would be displayed from the app's entry point or another parent view.

Example: Mutable State in SwiftUI

In SwiftUI, a value that drives interactive UI changes often needs an appropriate state-management mechanism. A plain local variable inside a view's computed body is not a replacement for managed state.

import SwiftUI

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

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

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

The @State property wrapper lets SwiftUI manage this view's local state and refresh the interface when the value changes. This is a practical extension of the difference between immutable constants and mutable values.

16. Common Mistakes and How to Fix Them

Example: Fixing a Type Mismatch

Incorrect code:

var studentAge = 20
studentAge = "Twenty"

Corrected code if the age is numeric:

var studentAge = 20
studentAge = 21

Alternatively, if the program needs to store a written description rather than a numeric age, declare a string variable for that purpose.

17. Best Practices for Swift Variables and Constants

• Prefer let by default and use var only when reassignment is necessary.
• Choose descriptive names that explain what a value represents.
• Allow type inference to handle straightforward declarations.
• Add type annotations when they make the intended type clearer.
• Keep variable scope as small as practical.
• Avoid changing a variable in many unrelated places.
• Use string interpolation for readable messages.
• Do not confuse a constant binding with a deeply immutable object.
• Use SwiftUI state tools when a value must drive interactive view updates.
• Read compiler errors carefully; they often identify the declaration or assignment that needs attention.

18. Practical Exercises

Exercise 1: Personal Information

Create constants for your name, city, and age. Print each value using print().

Exercise 2: Simple Calculator

Declare two integer constants and calculate their sum, difference, product, and quotient. Print all results.

Exercise 3: Shopping Cart

Create a variable for the number of cart items. Add three items, remove one item, and print the final count.

Exercise 4: Student Marks

Create constants for a student's name and three subject marks. Calculate the total and average. Choose suitable numeric types for the calculations.

Exercise 5: Login Status

Create a Boolean variable named isLoggedIn. Change its value from false to true and print the result.

Exercise 6: SwiftUI Counter

Build a simple SwiftUI screen that displays a count and includes a button to increase it. Use @State to manage the changing value.

19. Mini Project: Student Result Calculator

Project objective: Create a basic Swift program that stores a student's details, calculates total marks and average marks, and prints a formatted result.

Project Code

import Foundation

let studentName = "Riya Sharma"
let subjectOne = 85
let subjectTwo = 90
let subjectThree = 88

let totalMarks = subjectOne + subjectTwo + subjectThree
let averageMarks = Double(totalMarks) / 3.0

var resultStatus = "Pass"

if averageMarks < 35 {
    resultStatus = "Needs Improvement"
}

print("Student Result")
print("Name: \(studentName)")
print("Subject 1: \(subjectOne)")
print("Subject 2: \(subjectTwo)")
print("Subject 3: \(subjectThree)")
print("Total Marks: \(totalMarks)")
print("Average Marks: \(averageMarks)")
print("Status: \(resultStatus)")

Project Explanation

• The student's name and individual marks are constants because they do not change in this example.
• totalMarks stores the sum of all three subject marks.
• Double(totalMarks) converts the integer total into a floating-point value for average calculation.
• resultStatus is a variable because the program may change its value based on the result.
• The if statement checks whether the average is below the specified threshold.
• String interpolation combines labels and values in the printed report.

Extension task: Add more subjects, validate the marks, calculate a percentage, and display a grade using conditional statements.

20. Interview Questions and Answers

Q1. What is Swift?

Answer: Swift is a programming language developed by Apple for creating software across Apple platforms, including native iOS applications.

Q2. What is a variable in Swift?

Answer: A variable is a named value that can be reassigned after initialization. It is declared using the var keyword.

Q3. What is a constant in Swift?

Answer: A constant is a named value that cannot be reassigned after it has been initialized. It is declared using the let keyword.

Q4. What is the difference between let and var?

Answer: let creates a constant binding, while var creates a variable that can be reassigned. Prefer let when reassignment is unnecessary.

Q5. What is type inference?

Answer: Type inference is the compiler's ability to determine the type of a declaration from its initial value or surrounding context.

Q6. What is a type annotation?

Answer: A type annotation explicitly specifies a type, such as var age: Int = 25.

Q7. Can a variable store values of different types?

Answer: Not by ordinary reassignment. A variable has a type, and new values assigned to it must be compatible with that type.

Q8. Why is Swift considered type-safe?

Answer: Swift checks the types of values and expressions to prevent many invalid operations, such as assigning a string to an integer variable.

Q9. What is string interpolation?

Answer: String interpolation inserts values or expressions into a string using the syntax \(expression).

Q10. Are semicolons required in Swift?

Answer: No. Semicolons are generally optional when statements are written on separate lines.

Q11. What is the difference between Int and Double?

Answer: Int represents whole numbers, while Double represents floating-point numbers that can include a fractional component.

Q12. Why should developers prefer constants when possible?

Answer: Constants prevent accidental reassignment, communicate intent, and can make code easier to reason about and maintain.

Q13. Can a constant be initialized later?

Answer: In a local scope, a constant can be initialized later if Swift can verify that it receives a value before it is read and that initialization occurs correctly along all relevant paths.

Q14. What does print() do?

Answer: The print() function writes textual output to the program's output destination, such as the Xcode console.

Q15. How is mutable state represented in SwiftUI?

Answer: SwiftUI provides state-management tools such as @State for local view state, allowing view updates when the state changes.

21. Quick Revision Checklist

• let declares a constant.
• var declares a variable.
• Int represents whole numbers.
• Double represents floating-point values.
• String represents text.
• Bool represents true or false.
• Type inference lets Swift determine types from context.
• Type annotations explicitly specify types.
• String interpolation uses \(expression).
• Identifiers should be descriptive and follow Swift naming rules.
• Variables can be reassigned only with compatible values.
• Constants cannot be reassigned after initialization.
• Use @State or another suitable state mechanism for interactive SwiftUI data.

22. Conclusion

Understanding Swift syntax, variables, and constants provides the foundation for writing clear and reliable iOS applications. Swift's let and var keywords help developers express whether values should be reassigned, while its type system helps prevent invalid assignments and operations.

By practising declarations, data types, operators, type inference, type annotations, and string interpolation, learners can build the skills required for more advanced Swift topics such as conditions, loops, functions, collections, structures, classes, optionals, and SwiftUI application development.

23. Additional Learning Resources

• The Swift Programming Language: The Basics
• Apple: Review Swift Fundamentals
• Apple Swift Documentation
• Explore the iOS App Development Course at JustAcademy
• Register for a Course Demo
• Visit the JustAcademy Website