Book Image

Hands-On Design Patterns with Swift

By : Florent Vilmart, Giordano Scalzo, Sergio De Simone
Book Image

Hands-On Design Patterns with Swift

By: Florent Vilmart, Giordano Scalzo, Sergio De Simone

Overview of this book

Swift keeps gaining traction not only amongst Apple developers but also as a server-side language. This book demonstrates how to apply design patterns and best practices in real-life situations, whether that's for new or already existing projects. You’ll begin with a quick refresher on Swift, the compiler, the standard library, and the foundation, followed by the Cocoa design patterns – the ones at the core of many cocoa libraries – to follow up with the creational, structural, and behavioral patterns as defined by the GoF. You'll get acquainted with application architecture, as well as the most popular architectural design patterns, such as MVC and MVVM, and learn to use them in the context of Swift. In addition, you’ll walk through dependency injection and functional reactive programming. Special emphasis will be given to techniques to handle concurrency, including callbacks, futures and promises, and reactive programming. These techniques will help you adopt a test-driven approach to your workflow in order to use Swift Package Manager and integrate the framework into the original code base, along with Unit and UI testing. By the end of the book, you'll be able to build applications that are scalable, faster, and easier to maintain.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Design Patterns with Swift
Florent Vilmart | Giordano Scalzo | Sergio De Simone
Dec, 2018 | 414 pages
Small book image
Hands-On Full-Stack Development with Swift
Ankur Patel
Mar, 2018 | 356 pages
Small book image
Swift 3 New Features
Keith Elliott
Oct, 2016 | 142 pages
Small book image
Swift Functional Programming
Dr Fatih Nayebi
Apr, 2017 | 316 pages
Table of Contents (22 chapters)
Title Page
Title Page
Copyright and Credits
Copyright and Credits
About Packt
About Packt
Contributors
Contributors
Preface
Preface
Free Chapter
1
Refreshing the Basics
Refreshing the Basics
Classes and structs
Enums
Closures, functions, and currying
Protocols
Tuples, type aliases, and generics
Summary
2
Understanding ARC and Memory Management
Understanding ARC and Memory Management
A brief history of reference counting
ARC – what is that?
Memory debugging
Leaks, cycles, and dangling references
Summary
3
Diving into Foundation and the Standard Library
Diving into Foundation and the Standard Library
Swift basic types
Container types
Mastering concurrency with Dispatch
HTTP with URLSession
Summary
4
Working with Objective-C in a Mixed Code Base
Working with Objective-C in a Mixed Code Base
Setting up your project
Nullability and optionals in Objective-C
Naming, renaming, and refining Objective-C for Swift
Lightweight generics in Objective-C
Cocoa design patterns in Swift
Summary
5
Creational Patterns
Creational Patterns
The singleton pattern 
The factory method pattern
The abstract factory pattern
The builder pattern
The prototype pattern
Summary
6
Structural Patterns
Structural Patterns
The adapter pattern
The decorator pattern
The facade pattern and proxy pattern
The composite pattern
The bridge pattern
The flyweight pattern
Summary
7
Behavioral Patterns
Behavioral Patterns
The state pattern
The observer pattern
The memento pattern
The visitor pattern
The strategy pattern
Summary
8
Swift-Oriented Patterns
Swift-Oriented Patterns
Getting started with protocol-oriented programming
The type erasure pattern
Template pattern with protocol-oriented programming
Summary
9
Using the Model-View-Controller Pattern
Using the Model-View-Controller Pattern
A refresher on MVC
UIViewController
Composition and child view controllers
The model layer
Summary
10
Model-View-ViewModel in Swift
Model-View-ViewModel in Swift
Basics of the MVVM pattern
MVVM and data binding
Using Observables with ViewModels
Summary
11
Implementing Dependency Injection
Implementing Dependency Injection
Dependency Injection, a primer
Dependency Injection by example
Using a Dependency Injection Container
Summary
12
Futures, Promises, and Reactive Programming
Futures, Promises, and Reactive Programming
Callbacks and closures
Futures and promises
Reactive programming
Summary
13
Modularize Your Apps with Swift Package Manager
Modularize Your Apps with Swift Package Manager
Creating a library package
Adding third-party dependencies
Extracting and sharing a framework
Summary
14
Testing Your Code with Unit and UI Tests
Testing Your Code with Unit and UI Tests
Unit testing using XCTest
Advanced testing with mocks, spy, and others
UI testing with Xcode
Tips and tricks
Summary
15
Going Out in the Open (Source)
Going Out in the Open (Source)
Documenting Swift
Continuous integration
Using fastlane for automated delivery
Becoming a maintainer, tips and tricks
Summary
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

Container types

Container types are data types that are useful for containing other types. We'll spend this section covering the most prominent features of the most widely known and used containers: 

  • Array
  • Dictionary
  • Set

Arrays are unordered collections of the same element; dictionaries are keyed collections of elements; sets are unordered collections of unique elements.

Arrays

Unlike in Objective-C, a Swift array can only hold elements of the same type, and it's a value type.

The following code declares an Array container of three Int types,  1, 2, and 3:

let ints = [1,2,3] // Array<Int> or [Int]

As an example, if you wanted them to be Doubles, you could easily force the type on it:

let doubles: [Double] = [1,2,3]

Mutability and operations

These arrays are immutable, as they are defined as let; it is therefore not possible to add or remove elements from them. Hopefully, we can still make mutable copies of them:

var otherDoubles = doubles
otherDoubles.append(4)
let lastDoubles = otherDoubles.dropFirst...
Previous Section
End of Section 3
Next Section