Swift Apprentice
Swift Apprentice
About the authors
About the editors
Who this book is for
What you need
How to use this book
What's in store
Book source code and forums
Book updates
License
Acknowledgments
About the cover
How a computer works
- Representing numbers
- How code works
Playgrounds
- Creating a playground
- Playgrounds overview
Key points
Where to go from here?
Code comments
Printing out
Arithmetic operations
Math functions
Naming data
Increment and decrement
- Mini-exercises
Key points
Where to go from here?
Challenges
Type conversion
Strings
- How computers represent strings
- Unicode
Strings in Swift
Tuples
- Mini-exercises
A whole lot of number types
A peek behind the curtains: Protocols
Key points
Where to go from here?
Challenges
Comparison operators
The if statement
Loops
Key Points
Where to go from here?
Challenges
Ranges
For loops
- Continue and labeled statements
- Mini-exercises
Switch statements
Key points
Where to go from here?
Challenges
Function basics
Functions as variables
- The land of no return
Key points
Where to go from here?
Challenges
Introducing nil
- Sentinel values
Introducing optionals
- Mini-exercises
Unwrapping optionals
Introducing guard
Nil coalescing
Key points
Where to go from here?
Challenges
What is an array?
When are arrays useful?
Mutable versus immutable arrays
Creating arrays
Accessing elements
Modifying Arrays
Iterating through an array
Variadic Parameters
Running time for array operations
Key points
Where to go from here?
Challenges
Creating dictionaries
Accessing values
- Using subscripting
- Using properties and methods
Modifying dictionaries
Iterating through dictionaries
Running time for dictionary operations
Key points
Where to go from here?
Challenges
Closure basics
Custom sorting with closures
Iterating over collections with closures
- Mini-exercises
Key points
Where to go from here?
Challenges
Introducing structures
- Your first structure
- Mini-exercise
Accessing members
- Mini-exercise
Introducing methods
- Mini-exercise
Structures as values
Structs everywhere
Conforming to a protocol
Key points
Where to go from here?
Challenges
Stored properties
- Default values
Computed properties
- Mini-exercise
- Getter and setter
Type properties
Property observers
- Limiting a variable
- Mini-exercise
Lazy properties
- Mini-exercise
Key points
Where to go from here?
Challenges
- Challenge Set A: We all scream for ice cream
- Challenge Set B:
Method refresher
- Comparing methods to computed properties
- Turning a function into a method
Introducing self
- Mini-exercise
Introducing initializers
- Initializers in structures
Introducing mutating methods
Type methods
- Mini-exercise
Adding to an existing structure with extensions
- Keeping the compiler generated initializer using extensions
Key points
Where to go from here?
Challenges
Creating classes
Reference types
Understanding state and side effects
Extending a class using an extension
When to use a class versus a struct
Key points
Where to go from here?
Challenges
- Challenge A: Movie lists — benefits of reference types
- Challenge B: T-Shirt store — class or struct?
Introducing inheritance
Inheritance and class initialization
When and why to subclass
Understanding the class lifecycle
Key points
Where to go from here?
Challenges
Your first enumeration
Raw values
Associated values
Enumeration as state machine
- Mini-exercise
Case-less enumerations
- Mini-exercise
Optionals
Key points
Where to go from here?
Challenges
Introducing protocols
Implementing protocols
Protocols in the standard library
Key points
Where to go from here?
Challenges
- Challenge A: Bike protocols
- Challenge B: Pet shop tasks
Introducing generics
- Values defined by other values
- Types defined by other types
Anatomy of generic types
Arrays
Dictionaries
Optionals
Generic function parameters
Key points
Where to go from here?
Challenges
- Challenge A: Building a collection
- Problems introduced by lack of access control
Introducing access control
Organizing code into extensions
- Extensions by behavior
- Extensions by protocol conformance
Key points
Challenges
Custom operators
Subscripts
Key points
Where to go from here?
Challenges
Introducing patterns
Basic pattern matching
- if and guard
- switch
- Mini exercise
- for
Patterns
Advanced patterns
Programming exercises
Expression pattern
- Overloading ~=
Key points
Challenges
What is error handling?
First level error handling with optionals
Error protocol
Throwing errors
Handling errors
- Not looking at the detailed error
- Stoping your program on an error
Advanced error handling
- PugBot
- Handling multiple errors
Rethrows
Key points
Where to go from here?
Challenges
Reference cycles for classes
- Weak references
- Unowned references
Reference cycles for closures
- Capture lists
- Unowned self
Handling asynchronous closures
Key points
Where to go from here?
Challenges
- Challenge A
- Challenge B
Value types vs. reference types
- Reference types
- Value types
Defining value semantics
- When to prefer value semantics
Implementing value semantics
Recipes for value semantics
Key Points
Where to go from here?
Challenges
Introducing protocol extensions
Default implementations
- Mini-exercise
Understanding protocol extension dispatching
Type constraints
- Mini-exercise
Protocol-oriented benefits
Why Swift is a protocol-oriented language
Key points
Where to go from here?
Challenges
- Challenge A: Protocol extension practice
- Challenge B: Randomization

Powered by GitBook

Mini-exercise

Mini-exercise

What’s different in the two-phase initialization in the base class Person, as compared to the others?

results matching ""

No results matching ""