Swift Cheat Sheet

Updated 2026-08-01

🧠Study flashcards on this topic154 cards · spaced repetition→

Swift is Apple's modern, type-safe programming language for iOS, macOS, watchOS, tvOS, and visionOS development, introduced in 2014 to replace Objective-C. Designed with protocol-oriented programming at its core, Swift combines the performance of compiled languages with the expressiveness of scripting languages while prioritizing safety through features like optionals, strong typing, and Swift 6's compile-time data-race safety. A key mental model: Swift encourages value types (structs) over reference types (classes) for better performance and predictability — think "copy-by-default" rather than "share-by-reference," which fundamentally shapes how you architect Swift applications.

What This Cheat Sheet Covers

This topic spans 28 focused tables and 221 indexed concepts, 154 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Type System FundamentalsTable 2: Optionals and UnwrappingTable 3: Control Flow and Pattern MatchingTable 4: Functions and ClosuresTable 5: CollectionsTable 6: Strings and TextTable 7: Regular Expressions and String ProcessingTable 8: Property TypesTable 9: GenericsTable 10: Memory Management (ARC)Table 11: Noncopyable Types and OwnershipTable 12: Error HandlingTable 13: Concurrency (async/await)Table 14: Protocols and ExtensionsTable 15: Codable / SerializationTable 16: Type Casting and InspectionTable 17: Advanced OperatorsTable 18: Higher-Order FunctionsTable 19: Property WrappersTable 20: SwiftUI Layout ContainersTable 21: SwiftUI NavigationTable 22: InitializationTable 23: Access ControlTable 24: Attributes and AnnotationsTable 25: SubscriptsTable 26: Opaque and Existential TypesTable 27: Swift MacrosTable 28: Swift Testing

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Type System Fundamentals

The named-type building blocks every Swift program is assembled from. The single decision that shapes most designs is the first one here — struct (a value, copied) versus class (a reference, shared) — and the protocol entry is the seed of Swift's protocol-oriented style.

Type	Example	Description
struct	`struct Point {` `var x: Int` `var y: Int` `}`	• Value type — copied on assignment or when passed • preferred for most data models.
class	`class Person {` `var name: String` `init(name: String) {` `self.name = name` `}` `}`	• Reference type allocated on the heap — shared when assigned • supports inheritance and deinitializers; use when shared mutable state or identity is needed.
enum	`enum Status {` `case success` `case failure(Error)` `}`	• Value type for a group of related values • supports associated values and raw values; enables exhaustive pattern matching.
protocol	`protocol Drawable {` `func draw()` `}`	• Defines a blueprint of requirements (methods, properties) that conforming types must implement • foundation of protocol-oriented programming.
tuple	`let point = (x: 10, y: 20)` `print(point.x)`	• Lightweight grouping of multiple values into a single compound value • useful for returning multiple values from functions.
typealias	`typealias Coordinate = (Int, Int)`	• Creates an alternative name for an existing type • improves readability without creating a new type.
CaseIterable	`enum Direction: CaseIterable {` `case north, south, east, west` `}` `Direction.allCases.count`	• Protocol that synthesizes `allCases` for enums without associated values • lets you enumerate every case at runtime.
indirect enum	`indirect enum Tree {` `case leaf(Int)` `case node(Tree, Tree)` `}`	• Lets an enum case store an instance of the same enum as an associated value • needed for recursive data structures like trees or linked lists; apply to the whole enum or to individual cases.

Table 2: Optionals and Unwrapping

Optionals are Swift's headline safety feature — the type system forces you to acknowledge "this might be nil" rather than crashing on a null pointer at runtime. These are the tools for getting at the value safely: if let and guard let for binding, ?? for a fallback, ?. for chaining, and the two forced-unwrap forms you should reach for only when you're certain.

Technique	Example	Description
optional type	`var name: String? = nil`	• Represents a value that may be absent (`nil`) • appending `?` to any type makes it optional — Swift's primary mechanism to eliminate null pointer crashes.

The rest of this section is part of the full cheat sheet

Table 3: Control Flow and Pattern Matching

The keywords that direct how code executes — conditionals, loops, and early exits. Swift's switch is the standout: it's exhaustive, has no implicit fallthrough, and can destructure values and add where conditions, making pattern matching a first-class tool rather than a C-style afterthought. The later rows cover guard for clean early exits, defer for guaranteed cleanup, and the if/switch expression form added in 5.9.

Statement	Example	Description
if-else	`if age >= 18 {` `print("Adult")` `}`	• Basic conditional execution • condition must be a Boolean (no implicit conversion from integers).

The rest of this section is part of the full cheat sheet

Table 4: Functions and Closures

Functions in Swift carry more nuance than in most languages — argument labels read like prose at the call site, defaults trim boilerplate, and inout lets you pass by reference. Closures are the other half: first-class anonymous functions that capture their surroundings, with trailing-closure syntax and capture lists ([weak self]) being the patterns you'll write daily, especially in SwiftUI and async code.

Technique	Example	Description
function declaration	`func greet(name: String) -> String {` `return "Hello, \(name)"` `}`	• Defines a reusable block of code with parameter labels, types, and return type • Swift requires explicit return type when not `Void`.

The rest of this section is part of the full cheat sheet

Table 1: Type System Fundamentals

Type	Example	Description
struct	`struct Point {` `var x: Int` `var y: Int` `}`	• Value type — copied on assignment or when passed • preferred for most data models.
class	`class Person {` `var name: String` `init(name: String) {` `self.name = name` `}` `}`	• Reference type allocated on the heap — shared when assigned • supports inheritance and deinitializers; use when shared mutable state or identity is needed.
enum	`enum Status {` `case success` `case failure(Error)` `}`	• Value type for a group of related values • supports associated values and raw values; enables exhaustive pattern matching.
protocol	`protocol Drawable {` `func draw()` `}`	• Defines a blueprint of requirements (methods, properties) that conforming types must implement • foundation of protocol-oriented programming.
tuple	`let point = (x: 10, y: 20)` `print(point.x)`	• Lightweight grouping of multiple values into a single compound value • useful for returning multiple values from functions.
typealias	`typealias Coordinate = (Int, Int)`	• Creates an alternative name for an existing type • improves readability without creating a new type.
CaseIterable	`enum Direction: CaseIterable {` `case north, south, east, west` `}` `Direction.allCases.count`	• Protocol that synthesizes `allCases` for enums without associated values • lets you enumerate every case at runtime.
indirect enum	`indirect enum Tree {` `case leaf(Int)` `case node(Tree, Tree)` `}`	• Lets an enum case store an instance of the same enum as an associated value • needed for recursive data structures like trees or linked lists; apply to the whole enum or to individual cases.

Table 2: Optionals and Unwrapping

Technique	Example	Description
optional type	`var name: String? = nil`	• Represents a value that may be absent (`nil`) • appending `?` to any type makes it optional — Swift's primary mechanism to eliminate null pointer crashes.

Table 3: Control Flow and Pattern Matching

Statement	Example	Description
if-else	`if age >= 18 {` `print("Adult")` `}`	• Basic conditional execution • condition must be a Boolean (no implicit conversion from integers).

Table 4: Functions and Closures

Technique	Example	Description
function declaration	`func greet(name: String) -> String {` `return "Hello, \(name)"` `}`	• Defines a reusable block of code with parameter labels, types, and return type • Swift requires explicit return type when not `Void`.