Introduction to Swift Programming

The Swift Language

Swift is a modern programming language created by Apple. It’s designed to be safe, fast, and expressive, which makes it a great choice for building apps. One of its key features is readability. Swift code often looks a lot like plain English, making it easier to write and maintain.

Swift is a powerful and modern programming language used to build applications for Apple’s platforms.

It handles many common programming errors automatically, which helps prevent crashes and bugs. This focus on safety doesn't slow it down; Swift is optimized for performance, running your code quickly and efficiently.

Variables, Constants, and Types

In Swift, you store data using variables and constants. A variable is a value that can change, while a constant is a value that, once set, cannot be changed. You declare variables with the var keyword and constants with the let keyword. It's a good practice to use let whenever possible to make your code safer and easier to understand.

// A constant cannot be changed after it's set.
let pi = 3.14159

// A variable can be changed.
var currentScore = 0
currentScore = 100 // This is valid

Every variable and constant has a type, which determines what kind of data it can hold. Swift is type-safe, meaning it helps you be clear about the types of values your code can work with. Some basic types include:

String: A piece of text, like "Hello".
Int: An integer, or whole number, like 42.
Double: A number with a fractional component, like 3.14.
Bool: A Boolean value, which can be either true or false.

Swift has a feature called type inference, where it can figure out the type of a variable or constant automatically based on the value you give it. You can also explicitly declare the type if you need to.

let message = "Hello, world!" // Inferred as String
let year: Int = 2024          // Explicitly an Int
let isReady: Bool = true      // Explicitly a Bool

Controlling the Flow

Programs often need to make decisions or repeat tasks. Control flow statements let you direct the path your code takes. The most common way to make a decision is with an if statement, which runs a block of code only if a certain condition is true.

let temperature = 75

if temperature > 70 {
    print("It's a warm day!")
}

You can provide an alternative path with else for when the condition is false. To repeat an action, you can use a for-in loop. This is great for working with collections of items, like ranges of numbers or arrays.

// Using a for-in loop to count from 1 to 5
for number in 1...5 {
    print("The number is \(number)")
}

Functions and Classes

As programs grow, you'll want to organize your code into reusable blocks. Functions are named blocks of code that perform a specific task. You can define a function and then "call" it whenever you need to execute that task. Functions can take inputs, called parameters, and can produce an output, called a return value.

// A function that takes a name and returns a greeting
func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

// Calling the function
print(greet(person: "Alice"))

To model more complex things, Swift uses an object-oriented approach. The primary building block for this is the class. A class is a blueprint for creating objects. It can have its own variables (called properties) and its own functions (called methods).

class Dog {
    var name: String
    var age: Int

    // An initializer method to set up a new Dog object
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    // A method for the Dog to perform an action
    func bark() {
        print("Woof!")
    }
}

// Create an instance of the Dog class
let myDog = Dog(name: "Fido", age: 3)
myDog.bark() // Prints "Woof!"

Handling Errors

Sometimes, things can go wrong in a program. A function might fail to do what it's supposed to. Instead of crashing, Swift has a robust system for handling errors. Functions that can fail are marked with the throws keyword. To call one, you use the try keyword inside a do-catch block.

The do block contains the code that might throw an error. If an error occurs, the code execution immediately jumps to the catch block, where you can handle the problem gracefully.

enum FileError: Error {
    case notFound
    case unreadable
}

func readFile(named name: String) throws -> String {
    // This is a pretend function that might fail.
    if name == "badfile.txt" {
        throw FileError.notFound
    } 
    return "File contents"
}

do {
    let contents = try readFile(named: "badfile.txt")
    print(contents)
} catch {
    print("An error occurred: \(error)")
}

This pattern makes your code more resilient by forcing you to think about and handle potential failures.

Quiz Questions 1/6

In Swift, which keyword is used to declare a constant, a value that cannot be changed once it's set?

Quiz Questions 2/6

What is the primary purpose of a function in Swift?

That's a quick tour of the fundamentals of Swift. These core concepts are the foundation you'll build upon as you create powerful applications.

Mastering macOS App Development