Free through lesson 3

Swift for Beginners

From setting up your environment through variables, control flow, collections, optionals, functions and closures, structs and classes, protocols, error handling and async/await. Fifty lessons that take you to the point where you can read and write Swift without Xcode and assemble a task manager that saves to JSON. Every piece of code and result shown was produced by actually running Apple Swift 6.3.3.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are grouped into seven chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: this cannot run inside the browser, so try it with your own swift command (Xcode Command Line Tools).

Chapter 1 — Getting started (lessons 1–8)

You get to grips with how Swift runs and get to the point of executing it yourself without Xcode. You cover variables, numbers, strings and standard input, and how to read compiler errors.

What Swift is (setting up and Hello World)

Starting without Xcode. Installing the Command Line Tools, getting clear on swift versus swiftc, and running your first line.

Free

print and comments

separator and terminator on print, the three kinds of comment, escape sequences and raw strings.

Free

let and var

Write let first. Type inference and type annotations, and the doorway to Swift's type safety: a type cannot change later.

Free

Numbers and operators

Dividing two Ints truncates. Int and Double never mix implicitly. Overflow does not corrupt anything silently; it stops.

String basics

Concatenation and multi-line strings. count works in grapheme clusters, so an emoji counts as one character.

String interpolation and methods

Embedding with \(value). Search, replace, split and trim. Why word[0] does not work, and what to write instead.

Standard input and type conversion

readLine() returns String?. The standard flow of trimming then passing to Int(...), and how to receive runtime arguments.

How to read a compiler error

The errors are finding it for you before you run. How to read the six most common patterns, and the habit of not leaving warnings alone.

Chapter 2 — Control flow (lessons 9–15)

You cover conditionals and repetition: pattern matching with if and switch, for-in and ranges, while, break and continue. You finish by assembling a number-guessing game.

Branching with if

No parentheses around the condition, braces always. else if runs top down. From Swift 5.9, if can be used as an expression.

Comparison and logical operators

&& and || short-circuit. Why you cannot write 0 < x < 100, and a readable way to test a range.

switch and pattern matching

No break needed, and exhaustiveness is enforced. Ranges, tuples and where make it more readable than a chain of if-else if.

for-in and ranges

... includes the end, ..< does not. enumerated and indices, skipping with stride, and reversed.

while and repeat-while

for when the count is known, while when it is not. repeat-while always runs at least once.

break, continue and labels

In a nested loop, break only leaves the inner one. A break inside a switch does not leave the loop. Labels solve both.

[Project] Build a number-guessing game

Combining random numbers, input checking and a limited number of attempts. Stack up working parts rather than writing the finished thing at once.

Chapter 3 — Collections and optionals (lessons 16–24)

You gather values with Array, Dictionary, Set and tuples, and transform them with map, filter and reduce. Optionals and guard — the crux of Swift — are covered here too, and you finish by aggregating sales data.

Array basics

A row of values of one type. Unlike a string it is subscriptable, but going out of range crashes at runtime. A let array cannot be changed.

Array methods and sorting

The -ed forms return a new value; the plain forms change the receiver. The slicing methods do not crash when out of range.

Dictionary basics

Key access is always optional. The order is not guaranteed. dict[key, default: 0] += 1 is the standard aggregation idiom.

Sets

No duplicates and no order. contains is O(n) on an Array and O(1) on a Set. The standard deduplication pattern.

Tuples and destructuring

A lightweight container that can hold different types. Its main use is returning several values from a function; also useful as a composite sort key.

map, filter and reduce

Transform, narrow and gather. compactMap discards the nils. Written as a chain, the work reads from the top down.

Optionals

The mechanism that expresses "there might be no value" in the type. How to use ?? and ?., and why you must not reach for !.

Optional binding and guard

if let is "what to do on success"; guard let is "leave if it fails". Early return removes the nesting.

[Project] Aggregate sales data

Rejecting broken rows, aggregating, and presenting with thousands separators and a bar chart. Write on the assumption that external data is broken.

Chapter 4 — Functions and closures (lessons 25–32)

You split work up by naming it, and learn to pass functions around as values. Argument labels, inout, closures, higher-order functions, generics and recursion, and on to refactoring.

Function basics

Swift makes the caller write argument labels too. Return an optional if it can fail, a tuple if it returns several things.

Default and variadic parameters

A default value saves you from breeding overloads. You cannot pass an array straight into a variadic parameter.

inout and function types

Swift's standard types are value types, copied when passed. Functions are values you can store, pass and return.

Closure basics

A function with no name. The five levels of abbreviation, and capturing the surrounding variables. The state outlives the function that made it.

Trailing closures and higher-order functions

If the last argument is a closure it can move outside the parentheses. Writing your own map and filter reveals what the standard library is.

Getting started with generics

The mechanism for taking a type as an argument. Without a constraint you can do nothing with it. Unlike Any, type safety is preserved.

Recursive functions

The base case is everything. Naive Fibonacci explodes in calls. Recursion pays off on nested structures.

[Project] Refactor into functions

Improving the structure without changing the behaviour. Naming each piece of work, separating computation from display, and making each part checkable on its own.

Chapter 5 — Structs and classes (lessons 33–38)

You create your own data types. The difference between struct and class (value types versus reference types), mutating, initialisers, inheritance, computed properties and observers.

Struct basics

Creating your own type. You get a memberwise initialiser for free. It is a value type, so it is copied.

Methods and mutating

A function written inside a type is a method. A method that changes self needs mutating. static belongs to the type itself.

Initialisers

Controlling initialisation by writing your own init. init? expresses "this might not be constructible" in the type, and confines validation to the type.

Classes and reference types

A class is a reference type. Assigning it points at the same object. Even a let class lets you change its properties. When in doubt, use a struct.

Inheritance and overriding

Only classes can be inherited from, and override must be explicit. The deeper the hierarchy, the harder it is to follow.

Computed properties and property observers

Properties that compute rather than store, willSet and didSet for reacting to change, lazy for deferred evaluation, and private(set).

Chapter 6 — Enums and protocols (lessons 39–42)

You turn the states something can be in into a type using enums with associated values, and gather behaviour with protocols and extensions. You finish by building an inventory system from structs and protocols.

Enums and associated values

Listing the possible values as a type. Associated values let each case carry different data. Optional is itself an enum.

Protocol basics

A promise about what something can do. A struct, class or enum can all conform, and to several at once.

Extensions and protocol extensions

Adding capability to an existing type after the fact. The default implementations in a protocol extension are the crux of protocol-oriented design.

[Project] Build inventory management with structs

Designing your types with struct and enum. Deriving state through computed properties, and returning results as an enum with associated values.

Chapter 7 — Practice and beyond (lessons 43–50)

throws, Result, file I/O, Codable, Swift Package Manager and async/await. You finish a task manager that saves to JSON, and see what to learn next.

Error handling (throws and do-catch)

Use throws when the reason for failure matters. The difference between try? and try!, error propagation, and guaranteeing cleanup with defer.

Handling success and failure with Result

An enum that expresses success or failure as a single value. throws to handle it there and then, Result to carry it around.

Reading and writing files

The String and Data methods are all you need. File work can always fail, so catch it with try and close in defer.

Working with JSON (Codable)

Conform to Codable and the conversion is done for you. JSON with mismatched types is rejected at decode time.

Swift Package Manager and modules

Package.swift is the blueprint. A target is a module, and anything used from outside needs public.

Making use of the standard library (Date, formatting and random numbers)

A Date has no display format of its own. Leave date arithmetic to Calendar and number formatting to NumberFormatter.

Async work with async and await

await does not mean "wait" but "suspend and yield". async let turns a sum of waiting times into the maximum of them.

[Project] Wrapping up and what to learn next

Reviewing the key points of all 50 lessons and building a to-do app that saves to JSON. Then where to go next.

Once you have finished all 50 lessons, look at Rust for Beginners, which leans towards safety in much the same way, or make types your weapon in TypeScript for Beginners. Membership unlocks every course.