Introduction to Swift

Getting Started with Swift

Swift is a modern, powerful programming language developed by Apple. It's the primary language for building apps for iOS, macOS, watchOS, and beyond. Swift is designed to be safe, fast, and expressive, making it a great choice for beginners and experienced developers alike. Let's dive into its fundamental building blocks.

Variables and Data Types

In programming, you need a way to store and manage information. Swift gives you two ways to do this: constants and variables.

A constant, declared with let, is a value that cannot be changed once it's set. Use it for things that won't change, like the number of days in a week or a user's birth date.

A variable, declared with var, can be changed. You'd use a variable for a user's score in a game or the current temperature.

let maxScore = 100 // This is a constant
var currentScore = 85 // This is a variable

currentScore = 90 // This is okay
// maxScore = 110  // This would cause an error!

Every constant and variable has a data type, which tells Swift 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:

Int: For whole numbers, like -10, 0, or 42.
Double: For numbers with a fractional component, like 3.14159 or -0.5.
String: For text, like "Hello, world!".
Bool: For true or false values.

Swift has a feature called type inference, where it can often figure out the data type on its own, so you don't always have to write it out.

// Swift infers the types for us
let anInteger = 7
let aDouble = 3.14
let aString = "Swift is cool"
let isReady = true

// You can also be explicit if needed
let anotherInteger: Int = 12

Controlling the Flow

Programs rarely run from top to bottom without any detours. Control flow is how you make decisions and repeat actions in your code.

The most common way to make a decision is with an if statement. If a certain condition is true, one block of code runs. If not, another block (the else part) can run instead.

let temperature = 75

if temperature > 80 {
    print("It's a hot day!")
} else {
    print("It's not too hot.")
}

To repeat actions, you use loops. A for-in loop is perfect for running a piece of code for each item in a collection, like an array of numbers.

let names = ["Anna", "Brian", "Charlie"]

for name in names {
    print("Hello, \(name)!")
}

Another type of loop is the while loop, which continues to run as long as a condition remains true. It's useful when you don't know in advance how many times you need to loop.

var countdown = 3

while countdown > 0 {
    print(countdown)
    countdown -= 1
}

print("Lift off!")

Organizing with Functions

Functions are reusable blocks of code that perform a specific task. They help you organize your code, avoid repetition, and make your programs easier to understand.

A function has a name, can accept input values (called parameters), and can return an output value. You define a function using the func keyword.

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

Once a function is defined, you can call it whenever you need to perform its task.

let message = greet(person: "Dana")
print(message) // Prints "Hello, Dana!"

Some functions don't need to return a value. They just perform an action. In Swift, a function that returns nothing has a return type of Void, which you can omit.

func printHelp() {
    print("This function prints help information.")
}

printHelp() // Call the function

Handling Errors

Sometimes things go wrong. A file might not exist, a network connection might fail, or a user might enter invalid input. Swift has a robust system for handling errors that allows you to respond to problems gracefully.

First, you define the kinds of errors that can happen. An enumeration (enum) that conforms to the Error protocol is a great way to do this.

enum VendingMachineError: Error {
    case invalidSelection
    case insufficientFunds(coinsNeeded: Int)
    case outOfStock
}

Next, you create a function that can throw one of these errors. You mark it with the throws keyword. Inside the function, you use throw to signal that an error has occurred.

func purchase(item: String, coinsDeposited: Int) throws {
    if coinsDeposited < 50 {
        throw VendingMachineError.insufficientFunds(coinsNeeded: 50 - coinsDeposited)
    }
    // ... more logic for purchasing
    print("Purchase successful!")
}

Finally, you call the function that can throw an error using try. You wrap the call in a do-catch block to handle any errors that are thrown.

do {
    try purchase(item: "Chips", coinsDeposited: 25)
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
} catch {
    print("An unknown error occurred.")
}

Quiz Questions 1/5

In Swift, which keyword is used to declare a value that cannot be changed after it is first assigned?

Quiz Questions 2/5

Due to Swift's type inference, you rarely need to explicitly declare the type of a variable or constant.

These are the fundamentals of Swift. Mastering variables, control flow, functions, and error handling provides a solid foundation for building complex and powerful applications.

Swift Data Structures and Algorithms