Learn Swift: The Complete Beginner’s Guide (Zero Experience Required)

What is Swift?

Swift is a programming language made by Apple. A programming language is simply a way to give instructions to a computer. You write those instructions in a specific format the computer understands, and the computer follows them.

Think of it like a recipe. A recipe is written in a specific format — ingredients first, then steps in order — because that’s how a cook expects to read it. Swift is the same idea: a specific format for writing instructions that a computer can read and follow.

Apple uses Swift to build iOS apps, Mac apps, Apple Watch apps, and more. When you learn Swift, you’re learning the same language that Apple’s own engineers use every day.

Where do you actually write Swift?

You have two good options as a beginner, and both are free:

For the rest of Stage 1, instructions will say “open a Playground.” In Xcode: go to File → New → Playground, choose “Blank,” and you’re ready. In Swift Playgrounds on iPad: tap the + button and create a new blank playground.

What does a Swift program look like?

Here’s the simplest possible Swift program. This is real, working code:

print("Hello, world!")

That one line tells the computer: display the text “Hello, world!” on the screen. When you type it into a Playground and run it, that’s exactly what you’ll see.

How Swift runs your code

When you hit run, Swift reads your code from top to bottom, one line at a time, and executes each instruction in order. If you have three lines of code, it runs line 1 first, then line 2, then line 3. This is important to remember as your programs get longer.

Go deeper with AI

You already used print() in the last lesson. Now let’s understand it properly. It’s the most important tool you have as a beginner because it lets you see what’s happening inside your code.

print() does more than show text

You can print more than just words. You can print numbers, the result of a calculation, or even multiple things at once. Try all of these in a Playground:

// Printing text (words need quotation marks)
print("I am learning Swift")

// Printing a number (numbers don't need quotation marks)
print(42)

// Printing the result of a calculation
print(10 + 5)

// Printing multiple things separated by a comma
print("The answer is", 42)

// Printing a blank line (empty parentheses)
print()

Comments: notes in your code

You saw those lines starting with // in the code above. Those are called comments. They’re notes you write for yourself (or other developers) to explain what the code does. Swift completely ignores anything after // on a line.

// This whole line is a comment — Swift ignores it entirely
print("This line runs") // This part is a comment, but print() still runs

Get into the habit of adding comments to your code. Beginners often skip them, but they’re genuinely helpful when you come back to code you wrote a week ago and can’t remember what it was doing.

Basic math you can use inside print()

Swift understands the standard math operators you already know:

print(10 + 3)   // Addition → 13
print(10 - 3)   // Subtraction → 7
print(10 * 3)   // Multiplication → 30
print(10 / 3)   // Division → 3 (not 3.33... — we'll explain this soon)
print(10 % 3)   // Remainder → 1 (10 divided by 3 leaves remainder 1)

So far your code has used values directly — you typed the number 42, you typed “Hello, world!”. But real programs need to store information and use it in multiple places. That’s what variables and constants are for.

Think of it like a labeled box

Imagine a cardboard box with a label on it. You put something inside the box, and whenever you need it, you refer to it by the label instead of by what’s inside. Variables and constants work exactly the same way. You give a piece of information a name, and you use that name to refer to it throughout your code.

var: a box whose contents can change

// Create a variable called "score" and put the number 0 inside it
var score = 0

// Use it — print() now uses the value stored in "score"
print(score)   // 0

// Change the value stored in "score"
score = 10
print(score)   // 10

// You can do math with a variable
score = score + 5
print(score)   // 15

let: a box that’s sealed shut

Sometimes you have information that should never change. Like your date of birth, or the number of days in a week. For those, you use let instead of var.

// A constant — this value will never change
let daysInWeek = 7

print(daysInWeek)   // 7

// This would cause an error — you can't change a constant:
// daysInWeek = 8   ← Swift will refuse to compile this

If you try to change a constant, Swift won’t let your code run at all. It will show an error that says something like “cannot assign to value: ‘daysInWeek’ is a ‘let’ constant.” This is actually a feature — Swift is protecting you from accidentally changing something you didn’t mean to change.

Naming your variables

Variable names can be almost anything, but there are a few rules and conventions to follow:

// Good names — clear and descriptive
var playerName = "Alex"
var highScore = 1500
let maxLives = 3

// Swift uses "camelCase" — no spaces, each new word starts with capital
var numberOfItemsInCart = 0

// These would cause errors:
// var 1player = "Alex"    ← can't start with a number
// var player name = "Alex" ← can't have spaces

When you create a variable, Swift needs to know what kind of thing you’re storing. Is it text? A whole number? A number with a decimal? True or false? Each of those is a different data type, and Swift handles them differently.

In the last lesson, you created variables without thinking about types — Swift figured it out automatically. Let’s understand what’s actually happening.

The four most important data types

var name: String = "Aisha"
var city = "Toronto"  // Swift infers this is a String
var emptyText = ""    // An empty String is still a String

var age: Int = 28
var score = 1500       // Swift infers this is an Int
var temperature = -5  // Negative numbers work fine

var price: Double = 9.99
var height = 1.75       // Swift infers this is a Double
var pi = 3.14159       // Common math constants

var isLoggedIn: Bool = false
var hasCompletedLevel = true
var isPremiumUser = false

Type inference: Swift is smart

You’ve probably noticed that in most examples you don’t need to write the type explicitly. That’s because Swift can figure it out from the value you assign:

// With explicit type annotation (the part after the colon)
var name: String = "Jordan"
var score: Int = 100

// Without — Swift infers the same types automatically
var name2 = "Jordan"   // Swift sees quotes → String
var score2 = 100       // Swift sees whole number → Int
var price = 4.99       // Swift sees decimal → Double
var done = true        // Swift sees true/false → Bool

Both styles are correct. Beginners often leave out the type annotation since it’s less to type, and Swift handles it fine. You’ll want to add explicit types sometimes when Swift can’t infer correctly, but most of the time inference works perfectly.

Why you can’t mix types

Once a variable has a type, it keeps that type forever. You can’t store text in a variable that was created for numbers:

var score = 100      // score is now an Int

// This would cause an error:
// score = "one hundred"  ← can't put a String in an Int variable

// This is fine — still an Int:
score = 200

You know how to print text. You know how to print variables. Now it’s time to combine them — put the value of a variable right inside a sentence of text. This technique is called string interpolation, and once you learn it, you’ll use it in almost every Swift program you write.

The problem it solves

Imagine you want to print “Your score is 150” where 150 comes from a variable. Without string interpolation, you’d have to do something awkward like this:

var score = 150

// Awkward way — using a comma to join things
print("Your score is", score)   // Your score is 150 ✓ but limited

The comma approach works but it’s clunky — you can’t control spacing well, and it gets messy with complex sentences. String interpolation gives you a much cleaner way.

String interpolation: \( ) inside a string

To drop a variable’s value inside a string, you write a backslash followed by parentheses, with the variable name inside: \(variableName)

var score = 150
var playerName = "Maya"

// Use \( ) to drop the variable right into the string
print("Your score is \(score)")
print("Great job, \(playerName)!")
print("\(playerName) has \(score) points.")

You can put expressions inside \( )

It’s not just variable names you can put inside the parentheses. You can put any expression — a calculation, a combination, anything Swift can evaluate to a value:

var items = 3
var priceEach = 4.99

// A calculation inside the interpolation
print("Total: $\(items * priceEach)")

// Combining two strings
var firstName = "Jamie"
var lastName = "Chen"
print("Full name: \(firstName) \(lastName)")

// Using it with Bool
var isPremium = true
print("Premium account: \(isPremium)")

A common gotcha: the backslash

Quick reference: String interpolation patterns

Before your code can make a decision, it needs a way to ask a question. Is this number bigger than that one? Are these two words the same? Is the score high enough to win? These are all comparisons, and they’re the foundation of every decision your app will ever make.

Think about a bouncer at a venue checking IDs. Their job is simple: look at the age on the ID, compare it to the minimum age, and decide yes or no. Your code does the exact same thing. It compares two values and gets back a yes or a no.

In Swift, that yes-or-no answer is a Bool — either true or false. You already know what a Bool is from Stage 1. Now you’ll see where they actually come from.

let myAge = 20                        // Store an age as an Int
let minimumAge = 18                   // The age requirement to compare against

let isOldEnough = myAge >= minimumAge  // Is 20 greater than or equal to 18?
print(isOldEnough)                     // true

let isExactMatch = myAge == minimumAge  // Is 20 exactly equal to 18?
print(isExactMatch)                    // false

let isTooYoung = myAge < minimumAge    // Is 20 less than 18?
print(isTooYoung)                      // false

All Six Comparison Operators

print(5 == 5)            // true
print(5 == 6)            // false
print("hello" == "hello") // true — works with strings too
print("Hello" == "hello") // false — Swift is case-sensitive

print(5 != 6)           // true — 5 and 6 are different
print("cat" != "dog")   // true — they're not the same
print(10 != 10)         // false — they're equal, so "not equal" is false

print(3 < 10)   // true — 3 is less than 10
print(10 < 3)   // false — 10 is not less than 3
print(5 < 5)    // false — equal values don't count as "less than"

print(10 > 3)   // true — 10 is greater than 3
print(3 > 10)   // false — 3 is not greater than 10
print(5 > 5)    // false — equal values don't count as "greater than"

print(3 <= 5)   // true — 3 is less than 5
print(5 <= 5)   // true — equal counts here
print(6 <= 5)   // false — 6 is neither less than nor equal to 5

print(5 >= 5)   // true — exactly equal counts
print(6 >= 5)   // true — 6 is greater than 5
print(4 >= 5)   // false — 4 is neither greater than nor equal to 5

Quick Reference

Now that you can compare values and get a true or false result, you need a way to actually do something based on that result. That’s what an if statement does. It lets your code take different paths depending on a condition.

Think about a traffic light. When the light is green, cars go. When it’s yellow, they slow down. When it’s red, they stop. Each colour triggers a different action. An if statement works the same way: “if this condition is true, do this thing. Otherwise, do something else.”

This is one of the most important ideas in all of programming. Every app you’ve ever used relies on if statements constantly — checking if you’re logged in, if a form is filled out, if a score is high enough. Once you understand this, you can start writing code that actually responds to things.

let score = 75                     // A student's test score out of 100

if score >= 90 {                    // Check if score is 90 or above
    print("Grade: A")               // Only runs if the condition above is true
} else if score >= 80 {            // Only checked if the first condition was false
    print("Grade: B")               // Runs if score is 80 to 89
} else if score >= 70 {            // Only checked if both previous conditions were false
    print("Grade: C")               // 75 is in range 70–79 — this runs
} else {                            // Runs if none of the conditions above were true
    print("Grade: F")               // Covers anything below 70
}

The Three Forms of an if Statement

let isRaining = true

if isRaining {                       // A Bool is already true or false — no == needed
    print("Don't forget your umbrella!") // Only runs when isRaining is true
}
// If isRaining were false, nothing prints — and that's totally fine

let isLoggedIn = false

if isLoggedIn {
    print("Welcome back!")           // Runs when isLoggedIn is true
} else {
    print("Please sign in.")         // Runs when isLoggedIn is false — this one prints
}

let hour = 14                       // 2pm in 24-hour time

if hour < 12 {
    print("Good morning!")           // Hours 0 through 11
} else if hour < 18 {
    print("Good afternoon!")         // Hours 12 through 17 — hour 14 lands here
} else {
    print("Good evening!")           // Hour 18 and above
}

let hasTicket = true
let age = 16

if hasTicket {                       // First check: do they have a ticket?
    if age >= 18 {                   // Second check — only runs if they have a ticket
        print("Enjoy the show!")
    } else {
        print("Sorry, adults only.")    // Has ticket but is under 18 — this prints
    }
} else {
    print("No ticket, no entry.")
}

So far you’ve been checking one condition at a time. But real decisions usually involve more than one thing. “You can watch this movie if you’re 18 or older AND you have a subscription.” “You get a discount if it’s your birthday OR you’re a member.” These are multiple conditions combined into one decision.

Swift gives you three logical operators for exactly this. && means AND, || means OR, and ! means NOT. They let you combine or flip Bool values so you can express complex conditions without nesting a pile of if statements inside each other.

The good news is that these operators work exactly like the English words “and”, “or”, and “not”. Once you make that connection, they become very natural to read and write.

let age = 20                           // The user's age
let hasSubscription = true             // Whether they have an active subscription
let isBirthday = false                 // Whether today is their birthday

// AND: both conditions must be true for the whole thing to be true
if age >= 18 && hasSubscription {
    print("Enjoy the content!")          // Runs — both conditions are true
}

// OR: at least one condition must be true
if hasSubscription || isBirthday {
    print("You get a bonus reward!")     // Runs — hasSubscription is true (birthday doesn't matter)
}

// NOT: flip a Bool from true to false, or false to true
if !isBirthday {
    print("No birthday bonus today.")     // Runs — !false is true
}

let hasID = true
let isOnGuestList = false

if hasID && isOnGuestList {           // Both must be true — only hasID is true
    print("Welcome in!")
} else {
    print("Sorry, you need both.")      // This runs — isOnGuestList is false
}

let isStudent = false
let isSenior = true

if isStudent || isSenior {            // At least one must be true — isSenior is
    print("Discounted ticket!")         // This runs
} else {
    print("Full price.")
}

var isGameOver = false

if !isGameOver {                      // Read aloud: "if NOT isGameOver"
    print("Keep playing!")             // !false is true — this runs
}

let isWeekend = true
let hasChores = false
let friendsAvailable = true

// Can hang out if: it's the weekend AND (no chores OR friends are free)
if isWeekend && (!hasChores || friendsAvailable) {
    print("Let's go!")                 // Runs — all conditions satisfied
}

You’ve seen how if / else if / else handles multiple conditions. But when you’re checking one specific value against a list of possible options, a switch statement is often a much cleaner choice.

Think of a vending machine. You press A1 and get chips. You press B2 and get a drink. You press C3 and get chocolate. The machine doesn’t work through a long chain of “was it A1? No. Was it B2? No. Was it C3?” — it just checks the one value you gave it and jumps straight to the matching slot. That’s exactly what a switch statement does.

Swift’s switch statements are also more powerful than in many other languages. They can match ranges of numbers, multiple values at once, and they require you to handle every possible case — which catches bugs before they happen.

let day = "Monday"                   // The value we want to check

switch day {                           // Start the switch with the value to examine
case "Monday":
    print("Back to the grind.")        // "Monday" matches — this runs
case "Friday":
    print("Almost the weekend!")
case "Saturday", "Sunday":          // Two values can share one case
    print("Enjoy your weekend!")
default:                               // Handles any value not listed above
    print("Just another weekday.")
}

More Powerful Ways to Use switch

let score = 83

switch score {
case 90...100:                        // ... means "90 up to and including 100"
    print("Grade: A")
case 80...89:
    print("Grade: B")                   // 83 falls here — this runs
case 70...79:
    print("Grade: C")
default:
    print("Grade: F")
}

let month = 2                         // February

switch month {
case 1, 2, 3:                        // January, February, or March
    print("Winter / Early Spring")      // February is 2 — this runs
case 4, 5, 6:
    print("Spring / Early Summer")
case 7, 8, 9:
    print("Summer / Early Autumn")
case 10, 11, 12:
    print("Autumn / Winter")
default:
    print("Invalid month number")
}

let temperature = -5

switch temperature {
case let t where t < 0:             // Match any negative number, name it "t"
    print("Freezing: \(t) degrees")    // Runs — -5 is less than 0. "t" holds -5
case let t where t > 30:
    print("Very hot: \(t) degrees")
default:
    print("Temperature: \(temperature)")
}

You’ve been writing full if/else blocks to make decisions. Now meet the compact version: the ternary operator. It lets you express a simple two-option decision in a single line of code.

Think of it like a question with exactly two possible answers. “Is it raining? If yes — umbrella. If no — no umbrella.” The ternary operator is that structure compressed into one line: condition ? valueIfTrue : valueIfFalse. Ask a question, give the yes answer, give the no answer.

The word “ternary” just means it takes three parts: the question, the yes answer, and the no answer. Don’t let the name throw you off. Once you see the pattern a couple of times, it becomes second nature.

let temperature = 28                  // Current temperature in Celsius

// The long way with if/else:
var advice: String
if temperature > 25 {
    advice = "Wear sunscreen!"
} else {
    advice = "Bring a jacket."
}
print(advice)                          // "Wear sunscreen!"

// The short way with the ternary operator — same result, one line:
let quickAdvice = temperature > 25 ? "Wear sunscreen!" : "Bring a jacket."
print(quickAdvice)                     // "Wear sunscreen!"

Common Ways to Use the Ternary Operator

let isLoggedIn = true
let greeting = isLoggedIn ? "Welcome back!" : "Please sign in."
print(greeting)   // "Welcome back!"

let itemCount = 1
// Ternary inside \( ) picks the right word based on the count
print("You have \(itemCount) \(itemCount == 1 ? "item" : "items") in your cart.")
// "You have 1 item in your cart."  (not "1 items")

let isMember = false
let price = 10.00
let finalPrice = isMember ? price * 0.8 : price   // 20% off for members
print("Total: $\(finalPrice)")   // "Total: $10.0" — not a member, full price

// This works but is a nightmare to read:
let score = 75
let grade = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : "F"
print(grade)   // "C" — correct, but good luck reading that a month from now

// Use switch or if/else if instead — same result, much clearer

Imagine you had to write print("Hello!") ten times in a row. You could do it — but it would be tedious and silly. That’s exactly the kind of problem a loop solves.

A for loop runs a block of code a set number of times. Think of it like a lap counter at a running track. You decide how many laps, the runner goes, and the counter keeps track so you don’t have to.

In Swift, you tell a for loop how many times to run by giving it a range — a starting number and an ending number. Here’s the simplest version:

for i in 1...5 {          // run this loop for i = 1, 2, 3, 4, 5
    print("Lap \(i)")      // print the current lap number using string interpolation
}

The Two Range Operators

Swift has two ways to write a range, and they differ in one important way: whether the last number is included or not.

for i in 1...10 {
    print(i)    // prints 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
}

for i in 1..<10 {
    print(i)    // prints 1, 2, 3, 4, 5, 6, 7, 8, 9 — stops before 10
}

for _ in 1...3 {
    print("Hello!")    // prints "Hello!" exactly 3 times
}

// Count by 2s: 0, 2, 4, 6, 8, 10
for i in stride(from: 0, to: 11, by: 2) {
    print(i)
}

// Count down: 10, 8, 6, 4, 2, 0
for i in stride(from: 10, through: 0, by: -2) {
    print(i)
}

AI Practice Prompts

In the last lesson you looped over a range of numbers. But loops get really powerful when you loop over a list of actual things — names, scores, colors, whatever your app is working with.

That list is called an array. Think of an array like a numbered shelf with slots. Each slot holds one value, and you can have as many slots as you want. We’ll go deep on arrays in Stage 4 — but right now you just need to know enough to loop over one.

// Create an array of names — square brackets hold the list
let names = ["Alice", "Bob", "Charlie"]

// Loop over every name in the array
for name in names {
    print("Hello, \(name)!")    // name holds each value in turn
}

More Array Loop Patterns

let scores = [95, 82, 74, 100, 60]

for score in scores {
    if score >= 90 {
        print("\(score) — Great job!")
    } else {
        print("\(score) — Keep practicing.")
    }
}

let fruits = ["Apple", "Banana", "Cherry"]

for (index, fruit) in fruits.enumerated() {
    print("\(index + 1). \(fruit)")    // index starts at 0, so we add 1
}

let prices = [4.99, 12.50, 3.25, 7.00]
var total = 0.0          // starts at zero — declared with var so we can change it

for price in prices {
    total += price        // add each price to the running total
}

print("Total: \(total)")  // 27.74

AI Practice Prompts

A for loop is great when you know in advance how many times you want to repeat something. But what if you don’t know? What if you want to keep going until something changes?

That’s the job of a while loop. Think of it like a vending machine. It keeps taking coins as long as the balance is less than the item price. It doesn’t know upfront how many coins you’ll put in — it just checks each time and stops when the condition is met.

var coins = 0               // start with 0 coins
let price = 5               // the item costs 5 coins

while coins < price {         // keep looping as long as we don't have enough
    coins += 1               // add one coin each time
    print("Coins inserted: \(coins)")
}

print("Vending!")            // this runs after the loop ends

While Loop Variations

var attempts = 0

repeat {
    attempts += 1
    print("Attempt \(attempts)")
} while attempts < 3          // condition is checked AFTER each run

var number = 1

while true {                  // condition is always true
    print(number)
    number *= 2               // double the number each time
    if number > 100 {
        break                   // stop when number exceeds 100
    }
}

var isRunning = true         // this Bool controls the loop
var count = 0

while isRunning {
    count += 1
    print("Count: \(count)")
    if count == 4 {
        isRunning = false      // flip the flag to stop the loop
    }
}

AI Practice Prompts

Loops don’t always need to run perfectly from start to finish. Sometimes you hit a situation where you want to stop the whole loop early. Other times you want to skip just one pass but keep going. Swift gives you two keywords for this: break and continue.

Think of a conveyor belt at a factory. continue is like saying “skip this defective item, keep the belt running.” break is like hitting the emergency stop — the whole belt shuts off immediately.

// break: stop the loop the moment we find what we need
let items = ["pen", "notebook", "scissors", "tape", "stapler"]
let target = "scissors"

for item in items {
    print("Checking: \(item)")
    if item == target {
        print("Found it!")
        break            // stop the entire loop right here
    }
}

Notice the loop never checked “tape” or “stapler” — break stopped everything the moment we found what we were looking for.

Now here’s continue — it skips the rest of the current pass and jumps to the next one:

// continue: skip negative numbers, process only positives
let numbers = [3, -1, 7, -5, 2, 9]

for number in numbers {
    if number < 0 {
        continue         // skip this item and move to the next one
    }
    print("Positive: \(number)")
}

More Patterns with Break and Continue

var energy = 100

while true {
    energy -= 15
    print("Energy remaining: \(energy)")
    if energy <= 0 {
        print("Out of energy!")
        break            // exits the while true loop
    }
}

let words = ["swift", "xcode", "apple", "ios", "swiftui"]

for word in words {
    if !word.hasPrefix("swift") {    // if the word doesn't start with "swift"
        continue                         // skip it
    }
    print("Swift-related: \(word)")
}

outerLoop: for i in 1...3 {
    for j in 1...3 {
        if i == 2 && j == 2 {
            print("Stopping everything at (\(i), \(j))")
            break outerLoop     // exits the outer loop, not just the inner one
        }
        print("(\(i), \(j))")
    }
}

AI Practice Prompts

A nested loop is simply a loop inside another loop. The outer loop runs once, and for each pass of the outer loop the entire inner loop runs from start to finish. Then the outer loop goes to its next pass, and the inner loop runs all the way through again.

Think of a clock. The minute hand (outer loop) moves forward once per hour. Each time it does, the second hand (inner loop) completes a full 60-second cycle. For every 1 step of the outer loop, the inner loop takes 60 steps.

// Print a simple multiplication grid (3x3)
for row in 1...3 {                            // outer loop: rows
    for col in 1...3 {                        // inner loop: columns
        print("\(row) x \(col) = \(row * col)")
    }
    print("---")                            // runs after each full inner loop
}

Practical Nested Loop Patterns

// Simulate checking every seat in a cinema (5 rows, 8 seats each)
for row in 1...5 {
    for seat in 1...8 {
        print("Row \(row), Seat \(seat)")
    }
}
// Total: 40 iterations (5 x 8)

let grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

searchLoop: for row in grid {
    for value in row {
        if value == 5 {
            print("Found 5!")
            break searchLoop   // exit both loops at once
        }
    }
}

When Not to Use Nested Loops

Nested loops are a legitimate tool, but they’re also one of the easiest ways to accidentally write slow code. Here are the situations to watch out for:

// Unnecessary nesting — this just adds complexity for no reason
let names = ["Alice", "Bob", "Charlie"]
let greetings = ["Hi", "Hello", "Hey"]

// Bad: this prints every greeting for every name (9 outputs)
for name in names {
    for greeting in greetings {
        print("\(greeting), \(name)!")
    }
}

// Better: if you want one greeting per person, just use one loop
for name in names {
    print("Hi, \(name)!")
}

*
**
***
****
*****

AI Practice Prompts

Imagine you work at a coffee shop. Every morning when a customer orders a latte, you steam the milk, pull the espresso shot, combine them, add the lid. You do the exact same six steps every single time. Now imagine if every barista had to re-invent the latte procedure from scratch for each order — writing out every step on a notepad before they started. That would be absurd. Instead, the shop trains everyone once and says: “when someone orders a latte, do this.” That training is the function. The order is calling it.

In code, a function is a named block of instructions that you write once and run as many times as you need. Without functions, every time you wanted to do the same thing you would copy and paste the same lines over and over. That gets messy fast. Functions solve this with a principle programmers call DRY: Don’t Repeat Yourself.

Here is the problem without functions:

// Greeting three users — without a function
var name1 = "Alice"
print("Hello, \(name1)! Welcome to the app.")
print("We're glad you're here, \(name1).")

var name2 = "Bob"
print("Hello, \(name2)! Welcome to the app.")
print("We're glad you're here, \(name2).")

var name3 = "Carol"
print("Hello, \(name3)! Welcome to the app.")
print("We're glad you're here, \(name3).")

It works — but notice how you repeated the same two print lines three times. Now imagine changing the greeting wording. You would have to edit it in three places and hope you don’t miss one. This is exactly the kind of problem that leads to bugs. Functions fix it by letting you define the instructions once, name them, and just call that name.

You have already been calling functions without realising it. print() is a function. Apple wrote it once, named it print, and every time you type print("something") you are calling their function. Starting in Lesson 4.2, you will write your own.

Think of a function like a light switch. Someone wired up all the circuitry behind the wall — that wiring is the function definition. Once it’s done, anyone can flip the switch to turn the light on — that’s calling the function. The wiring only has to happen once. The flipping can happen a thousand times.

In Swift, you define a function using the func keyword, give it a name, add parentheses, and put the code you want to run inside curly braces. Here is the simplest possible function:

func sayHello() {                          // Define the function — wire up the switch
    print("Hello! Welcome to the app.")  // The code that runs when the function is called
}                                          // End of the function body

sayHello()  // Call the function — flip the switch (first time)
sayHello()  // Call it again (second time) — same instructions, zero extra code
sayHello()  // And again (third time)

Three calls, three outputs, and the actual instructions only lived in one place. If you want to change the greeting wording, you change it once inside the function and all three calls update automatically.

func showWelcomeMessage() {
    print("Welcome!")
    print("Tap anywhere to get started.")
}

showWelcomeMessage()

func drawSeparator() {
    print("──────────────")
}

print("Section One")
drawSeparator()
print("Section Two")
drawSeparator()
print("Section Three")
drawSeparator()

func printTitle() {
    print("My App")
}

func launchScreen() {
    printTitle()               // Calls another function from inside this one
    print("Loading...")
}

launchScreen()

Go back to the vending machine. A basic function is like a machine with one button that always gives you the same thing — a can of cola every time, no choices. That is useful, but limited. A real vending machine lets you pick what you want by pressing a button for a specific item. The item number you press is the parameter — the information you send into the machine to customise what comes out.

Parameters let a function do slightly different work each time it is called, based on the information you pass in. That is what transforms a simple function into something genuinely powerful.

func greetUser(name: String) {        // 'name' is the parameter — it has a label and a type
    print("Hello, \(name)!")           // Use the parameter like a regular variable inside
    print("We're glad you're here.")    // This line is the same every call
}

greetUser(name: "Alice")  // Call 1 — pass "Alice" as the name argument
greetUser(name: "Bob")    // Call 2 — same function, different input
greetUser(name: "Carol")  // Call 3 — same function, different input again

This is the greeting problem from Lesson 4.1 — solved. One function definition, three calls, zero repeated code, and changing the greeting wording now requires editing exactly one place.

func printScore(score: Int) {
    print("Your score is \(score) points.")
}

printScore(score: 42)
printScore(score: 100)

func showStatus(isLoggedIn: Bool) {
    if isLoggedIn {
        print("Welcome back!")
    } else {
        print("Please sign in.")
    }
}

showStatus(isLoggedIn: true)
showStatus(isLoggedIn: false)

func printLine(_ text: String) {    // The _ means "no label required when calling"
    print(text)
}

printLine("Hello!")    // No label needed — reads cleanly
printLine("Goodbye!")

So far, functions have been a one-way street. You send information in (via parameters) and the function does something with it — but it doesn’t hand anything back to you. Return values change that. A function with a return value works like a calculator: you give it numbers, it does the maths, and it hands back the result. You can then use that result anywhere in your code.

The arrow -> after the parentheses declares what type of value the function will return. The return keyword sends that value back to whoever called the function.

func addNumbers(a: Int, b: Int) -> Int {   // -> Int declares the return type
    let result = a + b                          // Do the work
    return result                               // Send the result back to the caller
}

let total = addNumbers(a: 10, b: 25)   // The returned value is stored in 'total'
print("Total: \(total)")                 // Use it like any other variable

let anotherTotal = addNumbers(a: 3, b: 7)
print("Another total: \(anotherTotal)")

func buildGreeting(name: String) -> String {
    let message = "Hello, \(name)! Welcome back."
    return message
}

let greeting = buildGreeting(name: "Alice")
print(greeting)

func isAdult(age: Int) -> Bool {
    return age >= 18           // Returns true if age is 18 or over, false otherwise
}

if isAdult(age: 21) {
    print("Access granted.")
} else {
    print("Access denied.")
}

func square(_ number: Int) -> Int {
    number * number   // No 'return' keyword — Swift infers it for single expressions
}

print(square(5))   // Prints 25

A coffee order has multiple details: size, type, milk preference, number of shots. The barista needs all of them to make the right drink. A function can receive multiple pieces of information in the same way — you simply list multiple parameters inside the parentheses, separated by commas. Each parameter has its own label and type.

func describeProduct(name: String, price: Double, inStock: Bool) -> String {
    let availability = inStock ? "In stock" : "Out of stock"   // Ternary from Stage 2
    return "\(name) — $\(price) — \(availability)"
}

let desc1 = describeProduct(name: "Swift Book", price: 29.99, inStock: true)
let desc2 = describeProduct(name: "iOS Course", price: 49.00, inStock: false)
print(desc1)
print(desc2)

func greet(user name: String) {  // 'user' is the external label, 'name' is used inside
    print("Hello, \(name)!")        // Inside the body, use 'name'
}

greet(user: "Alice")              // At the call site, use 'user'

func calculateTip(billAmount: Double, tipPercent: Double) -> Double {
    return billAmount * (tipPercent / 100)
}

let tip = calculateTip(billAmount: 45.50, tipPercent: 18)
print("Tip: $\(tip)")

Think about ordering a coffee. If you just say “a latte, please” without specifying size, the barista gives you a medium. Medium is the default. If you want something different, you say so — but you don’t have to. Default parameter values work exactly the same way. You assign a value to a parameter in the function definition, and then the caller can either pass their own value or leave it out entirely to use the default.

func sendWelcomeEmail(to name: String, subject: String = "Welcome!") {
    // 'subject' has a default value — the caller doesn't have to provide it
    print("To: \(name)")
    print("Subject: \(subject)")
    print("---")
}

sendWelcomeEmail(to: "Alice")                              // Uses default subject
sendWelcomeEmail(to: "Bob", subject: "You're In!")        // Overrides the default
sendWelcomeEmail(to: "Carol")                            // Uses default subject again

func formatPrice(amount: Double, currency: String = "USD", showDecimals: Bool = true) {
    if showDecimals {
        print("\(currency) \(amount)")
    } else {
        print("\(currency) \(Int(amount))")
    }
}

formatPrice(amount: 9.99)                                     // USD 9.99
formatPrice(amount: 9.99, currency: "EUR")                   // EUR 9.99
formatPrice(amount: 9.99, currency: "GBP", showDecimals: false) // GBP 9

func logMessage(_ message: String, verbose: Bool = false) {
    print("[LOG] \(message)")
    if verbose {
        print("  → Details: message length = \(message.count)")
    }
}

logMessage("App launched")              // Simple — verbose defaults to false
logMessage("User tapped button", verbose: true)  // Enables extra output

Imagine two different conference rooms in an office building. A conversation happening in Room A is completely private — nobody in Room B can hear it, and nothing said in Room A automatically affects what’s happening in Room B. Both rooms exist in the same building, but they are separate spaces. This is scope: the idea that variables only exist and are only visible inside the space where they were created.

In Swift, every set of curly braces creates its own scope. A variable declared inside a function exists only for the life of that function call. The moment the function finishes, those variables disappear. Code outside the function cannot see them, and code inside the function cannot see variables from other functions.

var appName = "MyApp"              // Declared at the top level (global scope)

func showAppName() {
    print(appName)                  // Can access appName — it's in a wider scope
    var localMessage = "Hello!"    // Only exists inside this function
    print(localMessage)
}

showAppName()

// print(localMessage)  ← This would be a compile error!
// localMessage doesn't exist outside the function

func functionOne() {
    var secret = "I'm in function one"
    print(secret)
}

func functionTwo() {
    // print(secret)  ← Compile error — 'secret' doesn't exist here
    var secret = "I'm in function two"  // Totally separate variable, same name is fine
    print(secret)
}

functionOne()
functionTwo()

Notice that both functions have a variable called secret. They are completely separate variables that happen to share a name. Changing one has zero effect on the other. This is one of the most important and useful features of scope — it means you don’t have to worry about naming conflicts between functions.

func checkScore(score: Int) {
    if score >= 80 {
        let grade = "Pass"        // 'grade' only exists inside this if block
        print("Grade: \(grade)")
    }
    // print(grade)  ← Compile error — 'grade' is out of scope here
    print("Score checked.")
}

checkScore(score: 90)

func doubleIt(_ number: Int) -> Int {
    let result = number * 2   // 'number' here is a local copy of whatever was passed in
    return result
}

var myNumber = 10
let doubled = doubleIt(myNumber)   // Passes the VALUE of myNumber — not the variable itself
print(myNumber)   // Still 10 — the function didn't touch the original
print(doubled)    // 20

Imagine you’re writing a shopping list. You could write each item on a separate sticky note, but that gets messy fast. Instead you write them all on one list, in order. That’s an array.

An array is an ordered collection of values of the same type. Instead of creating five separate variables to hold five names, you put all five names into one array. Swift keeps them in the order you added them, and you can access any item by its position in the list.

That position is called an index. Array indexes always start at 0, not 1. So the first item is at index 0, the second is at index 1, and so on. This trips up almost every beginner at least once, so keep it in mind.

// Creating an array of strings
var shoppingList: [String] = ["Apples", "Bread", "Milk"]

// Swift can infer the type — this works too
var scores = [98, 74, 85, 91]

// Creating an empty array — you must declare the type
var names: [String] = []

// Accessing items by index (remember: starts at 0)
print(shoppingList[0])  // "Apples"
print(shoppingList[2])  // "Milk"

// Arrays have a count property
print(shoppingList.count)  // 3

var tags = [String]()

var zeros = Array(repeating: 0, count: 5)
// Result: [0, 0, 0, 0, 0]

let fixedList = ["A", "B", "C"]  // cannot be changed
var growingList = ["A", "B"]     // can add or remove items

Now that you can create an array, you need to be able to do things with it. In a real app you’re constantly adding new items, removing old ones, checking whether something is in the list, and finding the first or last entry.

Swift gives you a set of built-in methods and properties that handle all of this. They’re built right into every array, so you call them using dot syntax — the same way you call .count.

var fruits = ["Apple", "Banana", "Cherry"]

// append — adds one item to the end
fruits.append("Mango")
print(fruits)  // ["Apple", "Banana", "Cherry", "Mango"]

// insert — adds an item at a specific index
fruits.insert("Kiwi", at: 1)
print(fruits)  // ["Apple", "Kiwi", "Banana", "Cherry", "Mango"]

// remove — removes the item at a specific index
fruits.remove(at: 0)
print(fruits)  // ["Kiwi", "Banana", "Cherry", "Mango"]

// contains — checks if an item exists, returns true or false
print(fruits.contains("Banana"))  // true
print(fruits.contains("Apple"))   // false

// first and last — optional properties
print(fruits.first!)  // "Kiwi"
print(fruits.last!)   // "Mango"

// count
print(fruits.count)  // 4

var numbers = [1, 2, 3]
numbers += [4, 5, 6]
print(numbers)  // [1, 2, 3, 4, 5, 6]

var cart = ["Shirt", "Shoes", "Hat"]
cart.removeAll()
print(cart.count)   // 0
print(cart.isEmpty) // true

var colors = ["Red", "Green", "Blue"]
colors[1] = "Yellow"
print(colors)  // ["Red", "Yellow", "Blue"]

let raw = [5, 2, 8, 1]
let ascending  = raw.sorted()           // [1, 2, 5, 8]
let descending = raw.sorted(by: >)     // [8, 5, 2, 1]
let flipped    = raw.reversed()        // sequence [1, 8, 2, 5]

In Stage 3 you learned how to loop over a range of numbers. Now you can combine that skill with arrays — and this is where things start to feel like real programming.

One of the most common things you do with an array is go through every item and do something with each one. Maybe you print them all, filter some out, or calculate a total. Swift gives you a clean syntax for this that you’ll use in nearly every app you write.

let temperatures = [22.5, 18.0, 30.1, 25.4, 19.8]

// Basic for-in loop — reads every item one at a time
for temp in temperatures {
    print("Temperature: \(temp)°C")
}

// Loop with a condition inside
print("Hot days:")
for temp in temperatures {
    if temp > 25.0 {
        print("\(temp)°C is a hot day")
    }
}

// Calculating a total using a running variable
var total: Double = 0.0
for temp in temperatures {
    total += temp   // add each temperature to total
}
let average = total / Double(temperatures.count)
print("Average: \(average)°C")

let players = ["Alice", "Bob", "Charlie"]
for (index, player) in players.enumerated() {
    print("Player \(index + 1): \(player)")
}
// Player 1: Alice
// Player 2: Bob
// Player 3: Charlie

let items = ["A", "B", "C"]
for i in items.indices {
    print("Index \(i): \(items[i])")
}
// Index 0: A
// Index 1: B
// Index 2: C

let names = ["Zara", "Leo", "Mia"]
names.forEach { name in
    print("Hello, \(name)!")
}

Think about a physical contact book. You don’t look someone up by their position in the book — you look them up by their name. “Alice” maps to her phone number. “Bob” maps to his. The name is the lookup key and the phone number is the value it points to.

That’s exactly what a dictionary is in Swift. Instead of accessing data by a numbered index like an array, you access it by a meaningful key. Each key must be unique and maps to exactly one value.

Dictionaries are unordered — Swift does not guarantee the items will come back in any particular sequence. If order matters, use an array. If lookup by a meaningful label matters, use a dictionary.

// Creating a dictionary [KeyType: ValueType]
var contactBook: [String: String] = [
    "Alice": "555-1234",
    "Bob":   "555-5678",
    "Carol": "555-9012"
]

// Reading a value — returns an Optional
if let phone = contactBook["Alice"] {
    print("Alice's number: \(phone)")
}

// Adding a new key/value pair
contactBook["Dan"] = "555-3456"

// Updating an existing value
contactBook["Bob"] = "555-0000"

// Removing a key/value pair
contactBook["Carol"] = nil

// Looping over a dictionary
for (name, number) in contactBook {
    print("\(name): \(number)")
}

print("Total contacts: \(contactBook.count)")

let score = contactBook["Unknown", default: "No number"]
print(score)  // "No number"

let allKeys   = Array(contactBook.keys)
let allValues = Array(contactBook.values)
print(allKeys)    // e.g. ["Alice", "Bob", "Dan"] (order not guaranteed)
print(allValues)  // e.g. ["555-1234", "555-0000", "555-3456"]

var userProfile: [String: Any] = [
    "name": "Alice",
    "age":  28,
    "isPremium": true
]

You now know about arrays and dictionaries. There’s one more collection type worth knowing: the set.

A set is like an array, but with two important differences. First, a set never contains duplicates — if you try to add a value that’s already there, nothing happens. Second, a set is unordered — like a dictionary, Swift makes no guarantees about sequence.

Think about a guest list for a party. You don’t care what order the names are in, and each person can only appear once. That’s a set.

// Creating a set — note the explicit type annotation
var tags: Set<String> = ["swift", "ios", "mobile"]

// Inserting an item
tags.insert("apple")

// Inserting a duplicate — nothing happens
tags.insert("swift")
print(tags.count)  // still 4, not 5

// Checking membership — sets are fast at this
print(tags.contains("ios"))    // true
print(tags.contains("android")) // false

// Removing an item
tags.remove("mobile")

// Set operations
let setA: Set = [1, 2, 3, 4]
let setB: Set = [3, 4, 5, 6]

print(setA.union(setB))        // all items from both: {1, 2, 3, 4, 5, 6}
print(setA.intersection(setB)) // items in both: {3, 4}
print(setA.subtracting(setB))  // items in setA but not setB: {1, 2}

Comparison: All Three Collection Types

let rawList = ["swift", "ios", "swift", "mobile", "ios"]
let unique  = Array(Set(rawList))
print(unique)  // ["mobile", "swift", "ios"] (order may vary)

// Does order matter? → Array
let messages = ["Hello", "How are you?", "Great!"]

// Do you need lookup by name/key? → Dictionary
let config: [String: Bool] = ["darkMode": true, "notifications": false]

// Do you need unique values and fast membership checks? → Set
var viewedArticleIDs: Set<Int> = [101, 204, 309]

Before we look at any code, let’s talk about a box.

Imagine you order a gift online. It arrives in a box. You shake the box — it might have something inside, or the seller might have shipped an empty box by mistake. You don’t know until you open it. That uncertainty is exactly what an optional represents in Swift.

In most of the Swift code you have written so far, your variables always had a value. You declared var name = "Chris" and name was always a String. There was never a question of whether the value existed. It always did.

But real-world data doesn’t work that way. Think about these situations:

• A user fills out a form — but the middle name field is optional. Not everyone has one.
• You ask the user to type a number, but they type “hello” instead. The conversion fails. There is no number.
• You look up a username in a database. That username might not exist.
• You try to find the first item in an array. The array might be empty.

In each of those situations, a value might be there, or it might not. Swift uses a special type to represent this uncertainty: an Optional.

An optional is like a container. The container either holds a value of the type you expect, or it holds a special placeholder called nil. nil means “nothing” — there is no value inside this container right now.

You create an optional by adding a question mark after the type name. Here is what that looks like:

// A regular String — it must always have a value
var regularName: String = "Chris"

// An optional String — it might have a value, or it might be nil
var optionalName: String? = "Taylor"

// Setting an optional to nil — this means "no value right now"
var unknownName: String? = nil

// You can also declare an optional without assigning anything
// Swift automatically sets it to nil by default
var middleName: String?

print(optionalName)   // Optional("Taylor")
print(unknownName)    // nil

Notice that when you print an optional that has a value, Swift shows it wrapped in Optional(...). That wrapping is Swift showing you the container, not just the value inside. You will learn how to get the value out of the container in Lesson 6.3.

var age: Int? = 25       // optional Int with a value
var score: Double? = nil   // optional Double with no value
var isLoggedIn: Bool?      // optional Bool — starts as nil automatically

// Int() tries to convert a String to an Int
// It returns an optional because the conversion might fail
let input = "42"
let converted = Int(input)   // converted is Int? — might be nil

let bad = "hello"
let result = Int(bad)        // result is nil — "hello" is not a number

Here’s a question you might be asking yourself: why does Swift make such a big deal about nil? Other programming languages just let you have a null value anywhere and deal with the consequences later. Why does Swift care so much?

The answer is crashes. Specifically, it’s avoiding the single most common crash in programming history. In many languages, if you try to use a variable that holds null (the equivalent of nil), your program crashes immediately. These crashes are called null pointer exceptions, and they have caused more broken apps, more frustrated users, and more late-night debugging sessions than almost anything else in the history of software development.

Swift’s designers made a deliberate choice: they would make it impossible to accidentally use a nil value as if it were a real value. If you try to use an optional as though it definitely has a value, Swift will refuse to compile your code. It won’t even run. The error is caught before you ever ship the app to a user.

This is the compiler acting as your safety net. Let’s see what Swift refuses to let you do:

var username: String? = "christing"

// This will NOT compile. Swift says: Value of optional type
// 'String?' must be unwrapped to refer to member 'count'
let length = username.count   // ERROR

// You also can't use an optional String directly where a String is expected
func greet(name: String) {
    print("Hello, \(name)!")
}

greet(name: username)   // ERROR — String? is not the same as String

// You also can't assign nil to a regular variable
var regularName: String = nil   // ERROR — regular types can never be nil

Every one of those lines is a compile-time error. Swift won’t let the program run until you handle the optionals properly. That might feel annoying right now, but consider the alternative: a user is using your app, hits a nil value you didn’t expect, and the app crashes. No warning. No second chances. That’s what Swift is protecting you from.

Think of it like a car with a manual transmission. You cannot accidentally put it in drive without deliberately going through the steps. The system is designed to make accidents harder, not easier. Optionals are Swift’s manual transmission for nil values.

// The error message Swift gives you is actually telling you exactly what to do

var score: Int? = 95

// This gives: "Value of optional type 'Int?' must be unwrapped"
let doubled = score * 2   // ERROR

// "must be unwrapped" means: open the box first, then use what's inside
// The next lessons show you exactly how to do that

// Tony Hoare, who invented null references in 1965, later called it
// "my billion-dollar mistake" — null/nil has caused so many bugs and
// crashes across the history of software that the cost is incalculable.

// Swift was designed so that nil can only exist where you explicitly
// allow it (by using the ? suffix) and must be handled before use.
// This turns what used to be a runtime crash into a compile-time error.

You know what an optional is. You know why Swift forces you to handle nil. Now it’s time to learn the first and most fundamental tool for dealing with optionals: if let.

Going back to the gift box analogy: if let is the act of opening the box and checking whether something is inside. If there is something inside, you take it out and use it. If the box is empty, you handle that situation separately. Either way, you never reach into an empty box.

Here is the basic pattern:

var username: String? = "christing"

// if let opens the box and checks what's inside
if let name = username {
    // Inside this block, "name" is a regular String (not optional)
    // We know it has a value because we only get here if username wasn't nil
    print("Welcome back, \(name)!")
} else {
    // We get here if username was nil
    print("No username found.")
}

// Now let's try it with a nil value
var middleName: String? = nil

if let middle = middleName {
    print("Middle name: \(middle)")
} else {
    print("No middle name provided.")  // This runs
}

var username: String? = "christing"

// Modern Swift (5.7+) lets you reuse the same name
// instead of writing "if let name = username"
if let username {
    print("Welcome, \(username)!")  // username is a String here
}

var firstName: String? = "Chris"
var lastName: String? = "Ching"

// Unwrap both in one if let — only runs if BOTH have values
if let first = firstName, let last = lastName {
    print("Full name: \(first) \(last)")
} else {
    print("One or both names are missing.")
}

var age: Int? = 17

// Unwrap AND check a condition in one step
if let userAge = age, userAge >= 18 {
    print("Access granted.")
} else {
    print("Access denied.")  // Runs — age is 17
}

// User typed something — we don't know if it's a valid number
let userInput = "42"

if let number = Int(userInput) {
    // userInput was a valid number — number is an Int here
    print("You entered: \(number)")
    print("Doubled: \(number * 2)")
} else {
    print("That wasn't a valid number.")
}

if let is great when you want to do something inside a block if a value exists. But there is a different situation that comes up constantly in real iOS apps: you are at the start of a function, and if the optional doesn’t have a value, the whole function should stop. There is nothing useful to do without that value.

Imagine a function that loads a user’s profile from a server. If there is no user ID, there is no point in making the network request. You want to bail out early. That’s what guard let is designed for.

Here is a good way to think about it: if let says “if the value exists, do something with it”. guard let says “the value must exist — if it doesn’t, stop everything right now”.

func loadProfile(userID: String?) {

    // guard let: if userID is nil, we exit the function immediately
    // The "else" block MUST exit — return, throw, or break
    guard let id = userID else {
        print("No user ID — cannot load profile.")
        return   // Exit the function
    }

    // If we reach this line, id is a regular String — guaranteed
    // Notice that id is available for the REST of the function
    // (unlike if let, where it was only available inside the block)
    print("Loading profile for user: \(id)")
    print("Profile loaded successfully.")
}

loadProfile(userID: "user_12345")   // Loads profile
loadProfile(userID: nil)              // Prints error, returns early

// Use if let when you want to do something IF the value exists
// The unwrapped value is only available inside the block
if let nickname = user.nickname {
    print("Hi \(nickname)!")   // nickname exists here
}
// nickname does NOT exist here

// Use guard let when the function cannot proceed without the value
// The unwrapped value is available for the rest of the function
func processOrder(orderID: String?) {
    guard let id = orderID else { return }
    // id is available for the entire rest of the function
    print("Processing order: \(id)")
}

func sendMessage(from sender: String?, to recipient: String?, body: String?) {

    // Unwrap all required inputs at once
    guard let from = sender,
          let to = recipient,
          let message = body else {
        print("Missing required fields.")
        return
    }

    // All three are available and guaranteed to have values here
    print("\(from) → \(to): \(message)")
}

Sometimes you don’t need to do anything special when a value is nil. You just want a sensible default to fall back on. You want to say: “Use this value if it exists, otherwise use this other value instead.”

Swift has a very clean way to express that idea: the nil coalescing operator, written as two question marks: ??.

Think of it like a backup plan. You ask your first choice (the optional), and if that’s not available, you fall back to your second choice (the default value). The result is always a regular, non-optional value — so you can use it directly without any more unwrapping.

var nickname: String? = nil
let displayName = nickname ?? "Anonymous"
print(displayName)   // Anonymous

var savedVolume: Int? = 75
let volume = savedVolume ?? 50
print(volume)   // 75 — savedVolume had a value so the default wasn't used

var profileColor: String? = nil
print("Theme color: \(profileColor ?? "blue")")   // Theme color: blue

var preferredName: String? = nil
var username: String? = nil

// Try preferredName first, then username, then fall back to "Guest"
let displayName = preferredName ?? username ?? "Guest"
print(displayName)   // Guest — both optionals were nil

var city: String? = nil

// Without ??: prints "Optional(nil)" or "nil"
print(city)                       // nil

// With ??: always prints a clean String
print(city ?? "Unknown city")   // Unknown city

// Also useful inside string interpolation
print("Location: \(city ?? "Not set")")   // Location: Not set

Every optional tool you have learned so far — if let, guard let, ?? — deals with nil carefully. They check whether a value exists before using it. Swift provides one more way to get the value out of an optional, but this one is different. It doesn’t check. It just grabs.

Force unwrapping uses an exclamation mark after an optional to say: “I’m certain this optional has a value. Skip the check and give me the value right now.” It looks like this: username!

The problem is: if you are wrong — if the optional is actually nil — your app crashes immediately. Not an error message. Not a warning. A hard crash that kills the app right in front of your user.

var name: String? = "Chris"

// Force unwrap — works here because name actually has a value
print(name!)   // Chris

// Now change name to nil and force unwrap again...
name = nil
print(name!)   // CRASH: Fatal error: Unexpectedly found nil while unwrapping

So when, if ever, is force unwrapping acceptable?

There is a small set of situations where experienced developers use it deliberately. For example, when loading an image that is bundled with the app — you are certain the file exists because you put it there. Or when working with @IBOutlet properties that are connected in Interface Builder. In those cases, the developer has external knowledge that the value will never be nil.

As a beginner, you do not yet have the experience to know when those situations arise. The safe rule is: never use ! unless you can explain exactly why nil is impossible in that specific case, and you have verified it is impossible in all code paths.

// An implicitly unwrapped optional is declared with ! instead of ?
// It is treated as optional for storage, but as non-optional for use
var label: UILabel!   // Implicitly unwrapped — common in IBOutlets

// You can use it without unwrapping syntax
// But if it's nil when you access it, the app still crashes
// label.text = "Hello"   // Crash if label is nil

// You mostly see this in generated Xcode code, not code you write yourself

var username: String? = nil

// AVOID: force unwrap — crashes if username is nil
// let name = username!   ← don't do this

// PREFER: if let — handles nil safely
if let name = username {
    print(name)
}

// PREFER: ?? with a default — always safe
let name = username ?? "Guest"
print(name)

You have learned how to safely unwrap a single optional. But what about situations where you have a chain of optionals? Where to get to the thing you want, you have to go through several values that might each be nil?

Imagine a user profile. The user might not be logged in. If they are logged in, they might not have set an address. If they have an address, it might not have a postal code. To get the postal code, you have to get through three levels of “maybe”.

Without optional chaining, you would need a nested stack of if let statements — one inside the other, inside the other. It gets messy fast. Optional chaining gives you a cleaner way to navigate that chain using the ?. syntax.

// Set up some simple structs to model the data
struct Address {
    var street: String
    var postalCode: String
}

struct UserProfile {
    var name: String
    var address: Address?   // Address is optional — not all users have one
}

struct App {
    var currentUser: UserProfile?   // User is optional — might not be logged in
}

var app = App(currentUser: nil)

// Optional chaining with ?.  — each ? means "if this exists, keep going"
// If any part of the chain is nil, the whole expression returns nil
let postalCode = app.currentUser?.address?.postalCode

print(postalCode ?? "No postal code available")
// No postal code available — because currentUser was nil

// Now let's give the app a logged-in user with an address
let address = Address(street: "100 Main St", postalCode: "M5V 1A1")
let user = UserProfile(name: "Chris", address: address)
app.currentUser = user

let code = app.currentUser?.address?.postalCode
print(code ?? "No postal code available")
// M5V 1A1 — all parts of the chain had values

var optionalText: String? = "hello world"

// Call a method on an optional using optional chaining
let uppercased = optionalText?.uppercased()
print(uppercased ?? "no text")   // HELLO WORLD

var nilText: String? = nil
let result = nilText?.uppercased()
print(result ?? "no text")         // no text — nilText was nil

struct Company {
    var ceo: String?
}
struct Employee {
    var company: Company?
}

var employee = Employee(company: Company(ceo: "Chris"))

// Use optional chaining to navigate the chain, then unwrap the final result
if let ceoName = employee.company?.ceo {
    print("CEO: \(ceoName)")   // CEO: Chris
} else {
    print("No CEO found")
}

So far, the types you have worked with — String, Int, Bool — are all built into Swift. But what happens when you need to represent something more specific, like a user in your app, or a recipe, or a product in a store?

That is exactly what a struct is for. A struct lets you create your own custom data type by grouping related pieces of data together under one name.

Think of a struct like a blueprint. A blueprint for a house describes everything the house will have: how many rooms, what colour the walls are, whether there is a garage. The blueprint itself is not a house — but you can use it to create as many houses as you want, and each house can have its own values.

In the same way, a struct is a blueprint. You define it once, then use it to create as many instances as you need — each with its own data.

// Define a struct — this is the blueprint
struct Contact {
    var name: String       // stored property: the contact's name
    var email: String      // stored property: the contact's email
    var age: Int           // stored property: the contact's age
}

// Create an instance — this is a real contact made from the blueprint
var alice = Contact(name: "Alice", email: "alice@example.com", age: 28)

// Access individual properties with dot syntax
print(alice.name)   // Alice
print(alice.email)  // alice@example.com
print(alice.age)    // 28

// Create a second instance — completely separate from alice
var bob = Contact(name: "Bob", email: "bob@example.com", age: 34)
print(bob.name)     // Bob

struct Product {
    let id: String          // cannot be changed after creation
    var name: String        // can be updated
    var price: Double       // can be updated
}

var item = Product(id: "SKU-001", name: "Notebook", price: 12.99)
item.name = "Premium Notebook"  // fine — name is var
// item.id = "SKU-002"           // error — id is let

struct Address {
    var city: String
    var country: String
}

struct User {
    var name: String
    var address: Address  // property whose type is another struct
}

let user = User(
    name: "Maria",
    address: Address(city: "Toronto", country: "Canada")
)
print(user.address.city)  // Toronto

A struct does not just hold data — it can also do things. The data inside a struct is called properties. The actions a struct can perform are called methods. Together, they give your custom type both a description and a set of behaviours.

If properties are the nouns of a struct — the things it has — then methods are the verbs. Think of a bank account: it has a balance and an owner (properties), but it can also deposit money, withdraw money, and display a summary (methods).

struct BankAccount {

    // Properties — the data this struct holds
    let owner: String
    var balance: Double

    // Computed property — calculated from other properties, not stored
    var formattedBalance: String {
        "$\(balance)"               // returns a formatted string
    }

    // Method — a function defined inside the struct
    func printSummary() {
        print("\(owner)'s balance: \(formattedBalance)")
    }

    // Method that takes a parameter
    func canAfford(amount: Double) -> Bool {
        return balance >= amount          // returns true if balance covers the amount
    }
}

var account = BankAccount(owner: "Sam", balance: 500.0)
account.printSummary()              // call a method with dot syntax
print(account.canAfford(amount: 200.0))  // true
print(account.canAfford(amount: 750.0))  // false
print(account.formattedBalance)           // $500.0

struct Rectangle {
    var width: Double
    var height: Double

    // computed — calculated from width and height, not stored
    var area: Double {
        width * height
    }

    var perimeter: Double {
        2 * (width + height)
    }
}

let rect = Rectangle(width: 10, height: 5)
print(rect.area)       // 50.0
print(rect.perimeter)  // 30.0

struct TemperatureConverter {
    var celsius: Double

    func toFahrenheit() -> Double {
        (celsius * 9 / 5) + 32
    }

    func isFreezing() -> Bool {
        celsius <= 0
    }
}

let temp = TemperatureConverter(celsius: 22)
print(temp.toFahrenheit())  // 71.6
print(temp.isFreezing())   // false

Every time you create an instance of a struct, Swift needs to set up all of its properties before you can use it. The code that does that setup is called an initializer.

You have already been using one without thinking about it. When you write Contact(name: "Alice", email: "alice@example.com", age: 28), that is calling an initializer. Swift generated it automatically from your properties. This is called the memberwise initializer, and you get it for free with every struct.

But sometimes you want more control over how instances are created. Maybe some properties have sensible defaults. Maybe you want to accept simpler inputs and do some calculation before setting a property. That is when you write a custom initializer.

struct AppUser {
    var username: String
    var email: String
    var isPremium: Bool
    var joinedMessage: String

    // Custom initializer — we control what parameters are required
    init(username: String, email: String) {
        self.username = username        // self.username = the property, username = the parameter
        self.email = email
        self.isPremium = false           // default value — new users are never premium
        self.joinedMessage = "Welcome, \(username)!"  // calculated from the username
    }
}

// Notice: we only pass username and email — isPremium and joinedMessage are set automatically
let user = AppUser(username: "sarah_codes", email: "sarah@example.com")
print(user.joinedMessage)  // Welcome, sarah_codes!
print(user.isPremium)      // false

struct NotificationSettings {
    var soundEnabled: Bool = true    // default value right on the property
    var badgeEnabled: Bool = true
    var alertStyle: String = "banner"
}

// No arguments needed — all defaults apply
let defaults = NotificationSettings()

// Override just the ones you need
let custom = NotificationSettings(soundEnabled: false, badgeEnabled: true, alertStyle: "alert")
print(defaults.alertStyle)  // banner
print(custom.alertStyle)    // alert

struct Color {
    var red: Double
    var green: Double
    var blue: Double

    // Init from individual RGB values
    init(red: Double, green: Double, blue: Double) {
        self.red = red
        self.green = green
        self.blue = blue
    }

    // Convenience init for white (all channels equal)
    init(white: Double) {
        self.red = white
        self.green = white
        self.blue = white
    }
}

let red = Color(red: 1.0, green: 0.0, blue: 0.0)
let gray = Color(white: 0.5)

This is one of the most important concepts in Swift — and one that catches a lot of beginners off guard. The key question is: when you copy a piece of data and change the copy, does the original change too?

The answer depends on whether you are working with a value type (like a struct) or a reference type (like a class).

Think of it like this. Imagine you have a recipe written on a piece of paper. If you photocopy it and hand the copy to a friend who scribbles on it, your original is untouched — they changed their copy, not yours. That is a value type. Now imagine you and a friend are both looking at the same document on Google Docs. If they change it, you see the change too — you are both working with the same thing. That is a reference type.

// STRUCT — value type (each copy is independent)
struct PointStruct {
    var x: Int
    var y: Int
}

var pointA = PointStruct(x: 1, y: 2)
var pointB = pointA      // Swift makes a full copy of pointA
pointB.x = 99           // changing pointB does NOT affect pointA

print(pointA.x)  // 1 — unchanged
print(pointB.x)  // 99 — only pointB changed

// ─────────────────────────────────────────────

// CLASS — reference type (copies share the same object)
class PointClass {
    var x: Int
    var y: Int
    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }
}

var classA = PointClass(x: 1, y: 2)
var classB = classA      // classB points to the SAME object as classA
classB.x = 99           // changing classB ALSO changes classA

print(classA.x)  // 99 — classA changed too!
print(classB.x)  // 99

struct Score {
    var points: Int
}

var playerOne = Score(points: 100)
var playerTwo = playerOne   // independent copy
playerTwo.points = 250

print(playerOne.points)  // 100 — not affected
print(playerTwo.points)  // 250

// Great for: most data models in SwiftUI apps
// Safe, predictable — no surprising side effects

class GameSession {
    var score: Int = 0
    var level: Int = 1
}

let sessionA = GameSession()
let sessionB = sessionA   // same object — NOT a copy

sessionA.score = 500     // changes the shared object
print(sessionB.score)    // 500 — sessionB sees the change

// Great for: objects shared across many parts of the app
// Use with care — changes anywhere affect everyone

You have learned that structs are value types. Because of this, Swift treats a struct instance as if it is a snapshot — it expects the struct to stay the same unless you explicitly say otherwise. This creates a rule you will run into quickly: a regular method inside a struct cannot change the struct’s own properties.

When you do want a method to modify a property, you mark it with the keyword mutating. This tells Swift: yes, this method is allowed to change this struct’s data. Swift will then make sure you only call it on a variable (var), not a constant (let).

struct StepCounter {
    var steps: Int = 0
    var goal: Int = 10_000

    // Regular method — reads data, does not change anything
    func progressMessage() -> String {
        "\(steps) of \(goal) steps"
    }

    // mutating — this method is allowed to modify properties
    mutating func addSteps(_ count: Int) {
        steps += count                  // modifies the steps property
    }

    // mutating — can change multiple properties
    mutating func reset() {
        steps = 0                       // resets steps back to zero
    }

    // computed property — reads goal but does not change anything, so not mutating
    var isGoalReached: Bool {
        steps >= goal
    }
}

var counter = StepCounter()          // must be var — we plan to mutate it
counter.addSteps(3_500)
counter.addSteps(4_200)
print(counter.progressMessage())     // 7700 of 10000 steps
print(counter.isGoalReached)          // false
counter.addSteps(3_000)
print(counter.isGoalReached)          // true
counter.reset()
print(counter.steps)                  // 0

struct TrafficLight {
    var color: String

    mutating func next() {
        switch color {
        case "red":    color = "green"
        case "green":  color = "yellow"
        default:       color = "red"
        }
    }
}

var light = TrafficLight(color: "red")
light.next()
print(light.color)  // green
light.next()
print(light.color)  // yellow

struct Counter {
    var count: Int = 0
    mutating func increment() { count += 1 }
}

var mutableCounter = Counter()
mutableCounter.increment()   // fine — mutableCounter is var
print(mutableCounter.count)   // 1

let fixedCounter = Counter()
// fixedCounter.increment()   // error — cannot mutate a let constant

Think about a job listing. Before anyone gets hired, the company publishes a list of requirements: “You must be able to write reports, attend weekly meetings, and respond to email within 24 hours.” The company doesn’t care how you do those things — it just needs the guarantee that you can. A protocol in Swift works exactly the same way. It’s a list of requirements, not an implementation. It says “anyone who uses this protocol must provide these properties and methods.” It doesn’t say how.

You’ve already been using protocols without realizing it. Every time you conformed a struct to Identifiable in SwiftUI, or used Codable to decode JSON, you were working with protocols. This lesson pulls back the curtain and shows you what a protocol actually is at the Swift language level, so those familiar names finally make complete sense.

By the end of this lesson you’ll understand what a protocol is, how to define one yourself, and why they exist. You’ll also understand the key mental model: a protocol is a contract, not an implementation.

// Define a protocol — a contract that any conforming type must fulfill
protocol Describable {
    var description: String { get }   // must have a readable description property
    func describe()                      // must have a describe() method
}

// A struct that fulfills the contract
struct Book: Describable {
    var title: String
    var description: String { "A book called \(title)" }  // fulfills the property

    func describe() {                                         // fulfills the method
        print(description)
    }
}

let swift = Book(title: "Swift Programming")
swift.describe()   // A book called Swift Programming

What Can a Protocol Require?

protocol Named {
    var name: String { get }         // read-only — just needs to be readable
    var nickname: String { get set }  // read-write — must be changeable too
}

protocol Greetable {
    func greet() -> String                  // must return a String
    func greetPerson(named: String) -> String  // with a parameter
}

protocol Configurable {
    init(name: String)   // conforming type must have this initializer
}

struct Widget: Configurable {
    var name: String
    init(name: String) {   // fulfills the init requirement
        self.name = name
    }
}

protocol Flyable {
    func fly()
}

protocol Swimmable {
    func swim()
}

// Duck conforms to both — separated by commas
struct Duck: Flyable, Swimmable {
    func fly()  { print("Flap flap") }
    func swim() { print("Splash splash") }
}

Imagine you want to apply for a position that requires a driver’s license, a first aid certificate, and fluent Spanish. You don’t just say “I can do those things” — you go get each one and provide proof. Protocol conformance in Swift works the same way. You claim conformance by adding the protocol name after the colon, and Swift immediately checks whether you’ve actually fulfilled every single requirement. If you’re missing anything, it won’t compile.

You’ve already written conformance dozens of times. Every struct you wrote in SwiftUI that had an id property was conforming to Identifiable. Every time you wrote struct Model: Codable, you were declaring conformance. This lesson explains exactly what’s happening under the hood when you do that.

By the end of this lesson you’ll understand how to fulfill protocol requirements correctly, what the compiler checks for, and how to split conformance into an extension to keep your code tidy.

protocol Vehicle {
    var numberOfWheels: Int { get }    // read-only property requirement
    var color: String { get set }      // read-write property requirement
    func describe() -> String           // method requirement
}

struct Bicycle: Vehicle {
    var numberOfWheels: Int = 2        // stored property — fulfills { get }
    var color: String                   // stored property — fulfills { get set }

    func describe() -> String {          // fulfills the method requirement
        return "A \(color) bicycle with \(numberOfWheels) wheels"
    }
}

var myBike = Bicycle(color: "red")
print(myBike.describe())   // A red bicycle with 2 wheels

Conformance Patterns

struct Car: Vehicle {          // declare conformance here
    var numberOfWheels: Int = 4
    var color: String
    func describe() -> String {
        return "A \(color) car"
    }
}

struct Truck {                   // core type defined here
    var color: String
    var payload: Double
}

extension Truck: Vehicle {       // conformance added separately
    var numberOfWheels: Int { 18 }  // computed property fulfills { get }
    func describe() -> String {
        return "A \(color) truck carrying \(payload)kg"
    }
}

let vehicles: [any Vehicle] = [
    Bicycle(color: "blue"),
    Car(color: "red"),
    Truck(color: "black", payload: 5000)
]

// Call describe() on each — Swift knows they all have it
for vehicle in vehicles {
    print(vehicle.describe())
}

protocol Resettable {
    mutating func reset()   // protocol marks it mutating
}

struct Counter: Resettable {
    var count = 0
    mutating func reset() {  // struct also marks it mutating
        count = 0
    }
}

When you buy furniture from a flat-pack store, they include an instruction sheet. But they don’t include instructions for how to breathe while you assemble it — that’s so obvious it goes without saying. Swift’s standard library protocols work similarly: many of them come with sensible default behavior that Swift synthesizes automatically. You just declare conformance and Swift figures out the details.

You’ve bumped into these four protocols already, even if you didn’t know it. Used == to compare two values? That’s Equatable. Used a struct as a dictionary key? That required Hashable. Decoded a JSON response? That was Codable. These aren’t obscure advanced topics — they’re the everyday protocols you’ll add to almost every model struct you write.

By the end of this lesson you’ll know what each of these four protocols does, when to add it, and what Swift handles for you automatically versus what you need to implement yourself.

// Add Equatable so we can use == to compare two Temperatures
struct Temperature: Equatable, Comparable, Hashable {
    var celsius: Double

    // Comparable requires this one method — Swift synthesizes the rest
    static func <(lhs: Temperature, rhs: Temperature) -> Bool {
        return lhs.celsius < rhs.celsius
    }
}

let boiling  = Temperature(celsius: 100)
let freezing = Temperature(celsius: 0)
let body     = Temperature(celsius: 37)

print(boiling == freezing)           // false — Equatable
print(freezing < boiling)            // true — Comparable
print([boiling, freezing, body].sorted().first!.celsius)  // 0.0

The Four Protocols Every Beginner Needs

struct Color: Equatable {    // Swift synthesizes == automatically
    var red: Int
    var green: Int
    var blue: Int
}

let red  = Color(red: 255, green: 0,   blue: 0)
let red2 = Color(red: 255, green: 0,   blue: 0)
let blue = Color(red: 0,   green: 0,   blue: 255)

print(red == red2)   // true — all properties match
print(red == blue)   // false

struct Player: Comparable {
    var name: String
    var score: Int

    // Required: define what "less than" means for your type
    static func <(lhs: Player, rhs: Player) -> Bool {
        return lhs.score < rhs.score  // sort by score
    }
}

var players = [
    Player(name: "Alice", score: 92),
    Player(name: "Bob",   score: 78),
    Player(name: "Chen",  score: 88)
]

print(players.sorted().last!.name)  // Alice — highest score

struct Point: Hashable {  // Hashable implies Equatable
    var x: Int
    var y: Int
}

// Can now be used as a Set element
var visited: Set<Point> = []
visited.insert(Point(x: 1, y: 2))
visited.insert(Point(x: 1, y: 2))  // duplicate, won't be added
print(visited.count)               // 1

// Can also be a dictionary key
var labels: [Point: String] = [:]
labels[Point(x: 0, y: 0)] = "Origin"

struct User: Codable {      // Codable = Encodable + Decodable
    var name: String
    var age: Int
}

// Encode to JSON
let user = User(name: "Alice", age: 28)
let encoder = JSONEncoder()
if let data = try? encoder.encode(user) {
    print(String(data: data, encoding: .utf8)!)  // {"name":"Alice","age":28}
}

// Decode from JSON
let json = """{"name":"Bob","age":35}""".data(using: .utf8)!
let decoded = try? JSONDecoder().decode(User.self, from: json)
print(decoded?.name ?? "nil")   // Bob

Picture a house that's already built. You can't tear it down and rebuild it from scratch every time you want a new room — but you can add an extension. You're not changing the original structure; you're building onto it. Swift extensions work the same way. You can add new methods, computed properties, and even protocol conformance to any existing type — including types you didn't write, like Apple's own String, Int, or Array.

You've actually already used extensions — in Lesson 8.2 you saw how conformance can be added to a type in an extension block. But extensions can do more than just add protocol conformance. They're a powerful organizational tool and one of the reasons real Swift code stays readable even as it grows large.

By the end of this lesson you'll know how to write extensions on your own types and on Swift's built-in types, what you can and can't add in an extension, and the most common patterns you'll see in real codebases.

// Extend Swift's built-in String type with a new computed property
extension String {
    var wordCount: Int {
        // split by whitespace and count non-empty components
        return self.split(separator: " ").count
    }

    func shout() -> String {
        return self.uppercased() + "!!!"
    }
}

let sentence = "Swift is really fun"
print(sentence.wordCount)   // 4
print(sentence.shout())     // SWIFT IS REALLY FUN!!!

Extension Patterns

struct Rectangle {
    var width: Double
    var height: Double
}

// Add geometry helpers in a separate extension
extension Rectangle {
    var area: Double      { width * height }
    var perimeter: Double { 2 * (width + height) }
    var isSquare: Bool   { width == height }
}

extension Int {
    var isEven: Bool { self % 2 == 0 }
    var squared: Int { self * self }
    func times(_ action: () -> Void) {
        for _ in 0..self { action() }
    }
}

print(7.isEven)    // false
print(5.squared)   // 25
3.times { print("hello") }  // hello hello hello

struct Product {
    var name: String
    var price: Double
}

// Add Codable conformance later, in an extension
extension Product: Codable { }  // empty — Swift synthesizes everything

// Add a custom description in another extension
extension Product: CustomStringConvertible {
    var description: String {
        "\(name) — $\(String(format: "%.2f", price))"
    }
}