Swift Fundamentals for iOS Developers

Why Swift Matters

Swift is the primary language for modern iOS development because it combines performance, safety, expressive syntax, and a strong standard library. Students should not only memorize syntax. They should understand why Swift encourages value semantics, explicit optional handling, protocol-oriented design, and safer APIs.

Core Syntax and Type Safety

let appName = "Travel Planner"
var launchCount = 0

func greet(user: String) -> String {
    return "Welcome, \(user)"
}

Use let for values that should not change and var for mutable state. Swift's type system helps the compiler catch errors early, which is especially useful in large mobile applications where runtime crashes are costly.

Optionals and Safe Unwrapping

var username: String? = "Mira"

if let username = username {
    print(username.uppercased())
} else {
    print("No username available")
}

Optionals represent the presence or absence of a value. This is critical in iOS because user input, API responses, cached data, permissions, and device resources may all be unavailable at different times.

Structs, Classes, and Protocols

struct Product {
    let id: Int
    let name: String
}

protocol PriceFormatting {
    func formattedPrice() -> String
}

final class CartService: PriceFormatting {
    func formattedPrice() -> String {
        return "$49.99"
    }
}

Structs are often used for models and immutable data. Classes are used when shared mutable identity matters. Protocols help teams decouple components and make testing easier.

Collections, Closures, and Functional Style

let prices = [10, 20, 30, 40]
let discounted = prices.map { $0 - 2 }
let premium = discounted.filter { $0 >= 20 }
let total = premium.reduce(0, +)

Functional transformations are common in UI state preparation, response mapping, analytics aggregation, and business-rule pipelines.

Error Handling and Practical Mobile Coding

enum LoginError: Error {
    case invalidCredentials
    case networkUnavailable
}

func validate(username: String, password: String) throws {
    guard !username.isEmpty, !password.isEmpty else {
        throw LoginError.invalidCredentials
    }
}

Throwing explicit errors matters because mobile code deals with unreliable conditions: weak networks, permission denial, missing files, expired tokens, and invalid user actions.