Hands-On Design Patterns with Swift by Vilmart, Florent -- Read -- Imperial Library of Trantor

Index

Title Page Copyright and Credits

Hands-On Design Patterns with Swift

About Packt

Why subscribe? Packt.com

Contributors

About the authors About the reviewers Packt is searching for authors like you

Preface

Who this book is for What this book covers To get the most out of this book

Download the example code files Download the color images Conventions used

Get in touch

Reviews

Refreshing the Basics

Classes and structs

Classes Struct

Enums

Simple enums Adding methods Associating values Generic enums Raw type enums Switching the state of light

Closures, functions, and currying

Currying Using closures as callbacks Using weak and unowned

Protocols

Declaring a protocol Conforming to a protocol

Conformance at declaration Conformance in an extension

Protocol extensions

Default implementations

Tuples, type aliases, and generics

Tuples

Declaring tuples Destructuring tuples Using tuples in functions

Type aliases Generics

Generic functions Generic types Generics, protocols, and associated types

Summary

Understanding ARC and Memory Management

A brief history of reference counting

The semantics of reference counting

Retain Release Assign Copying

Using and misusing manual reference counting

Memory leaks Dangling pointers

ARC – what is that?

Value types Strong references Weak references Unowned references

Memory debugging

Configuring your project Using the memory graph hierarchy tool

Leaks, cycles, and dangling references

Leaking with cycles

A simple leak Fixing the leak

Using weak Using unowned

Dangling references

Summary

Diving into Foundation and the Standard Library

Swift basic types

Working with ranges

Range as Sequence

Throwing and catching errors

Container types

Arrays

Mutability and operations Iterating, mapping, and reducing

Dictionaries

Initialization and mutability Iterating, mapping, and reducing

Mastering concurrency with Dispatch

Tasks and queues Synchronization with Dispatch

Thread safety through serial queues Organizing execution with groups and semaphores

Example of a counting semaphore Using groups

HTTP with URLSession

Making your first call with URLSession Parsing responses with Decodable Sending requests with Encodable

Summary

Working with Objective-C in a Mixed Code Base

Setting up your project

Importing Objective-C in Swift Exposing Swift to Objective-C

Nullability and optionals in Objective-C

Using NS_ASSUME_NON_NULL_BEGIN and NS_ASSSUME_NON_NULL_END Using nullable, nonnull, _Nullable, and _Nonnull

Naming, renaming, and refining Objective-C for Swift

Setting Objective-C names from Swift Setting Swift names from Objective-C

Renaming classes Renaming methods and enum cases

Lightweight generics in Objective-C

Using typed NSArray* in Objective-C Generic classes in Objective-C

Cocoa design patterns in Swift

Delegation

Using delegation Implementing delegation

Lazy initialization

Summary

Creational Patterns

The singleton pattern

Using singletons Singletons in a nutshell

The factory method pattern

Using the factory method pattern Advanced usage of the factory method pattern Wrapping up

The abstract factory pattern

Using the abstract factory pattern Going further with factory methods

Default implementations

Inheritance Protocol extensions

Checklist for using the factory method pattern

The builder pattern

Model building Going further: metaprogramming with Sourcery The builder pattern in a nutshell

The prototype pattern

Leveraging the prototype pattern Going further – NSCopying with Sourcery

Implementing NSCopying automatically Implementing mutable objects Implementing NSMutableCopying automatically

The prototype pattern in a nutshell

Summary

Structural Patterns

The adapter pattern

Using the adapter pattern

The basics The classes to adapt Using classes as adapters Leveraging extensions

The adapter pattern in a nutshell

The decorator pattern

Using a decorator Going further with decorator Decoration in a nutshell

The facade pattern and proxy pattern

The facade pattern

Building a network cache with the facade pattern

Using the proxy pattern to implement request/response logging

The composite pattern

Using the composite pattern to represent tests and suites

The bridge pattern

Anatomy of the bridge pattern Using the bridge pattern

The flyweight pattern

A shopping list using the flyweight pattern

Summary

Behavioral Patterns

The state pattern

The card reader

Using enums Refactoring for maintainability

Extracting a single protocol Implementing all states through structs, and moving the logic Refactoring the context object

Using state machines

The observer pattern

Event-based programming

Using NotificationCenter Using Key-Value Observing

Using KVO with existing Objective-C APIs Using KVO with Swift

Observation using pure Swift

Using observation

The memento pattern

Components of the memento pattern Implementing the memento pattern Using the memento pattern

The visitor pattern

Visitable and visitor protocols Contributors, thank you notes, and the visitor pattern Using visitors

The strategy pattern

Components of the strategy pattern The ice-cream shop example Using the strategy pattern

Summary

Swift-Oriented Patterns

Getting started with protocol-oriented programming

A refresher on protocols

Adding requirements to protocols

Mutation and value types

Protocols are full-fledged types

Generics, conditional conformance, and associated types

Generics-based programming

Generic functions Generic everything

Conditional conformance Associated types

A word on Self requirement

Protocol-oriented programming

The type erasure pattern

Elements of type erasure Closure-based type erasure Boxing-based type erasure

The abstract base class The private box The public wrapper

The type erasure pattern – a summary

Template pattern with protocol-oriented programming

A recommendation engine Summing up with the template method pattern

Summary

Using the Model-View-Controller Pattern

A refresher on MVC

The theory behind the MVC pattern A pure MVC example

The model layer The view layer The controller layer

UIViewController

View controller life cycles UIViewController anti-patterns

Early view instantiation Early view access in initializer Early view access in properties

Composition and child view controllers

Adding child view controllers Removing child view controllers Using view controller composition

The model layer

Using model controllers Refactoring controllers

View controllers Model controllers The Controller

Summary

Model-View-ViewModel in Swift

Basics of the MVVM pattern

Refactoring MVC into MVVM

Model ViewModel View

Benefits and drawbacks of MVVM

Enhanced testing Improved reusability Drawbacks

MVVM and data binding

Implementing the Observable class Implementing the Binding protocol Two-way binding on UITextField

Using Observables with ViewModels Summary

Implementing Dependency Injection

Dependency Injection, a primer

What is Dependency Injection?

Definition

Why DI is useful

Separation of concerns Testability

Dependency Injection by example

Four ways to use Dependency Injection (with examples)

Constructor Injection Property Injection Method Injection Ambient Context

Bind the dependencies

Composition Root

DI anti-patterns

Control Freak

Stable and volatile dependencies

Bastard Injection Service Locator

Using a Dependency Injection Container

Why you should use a DI Container The Typhoon framework Swinject

Automatic Storyboard Injection

Summary

Futures, Promises, and Reactive Programming

Callbacks and closures

Closures and memory management The issue with callbacks

Futures and promises

Futures and promises under the hood Futures and promises frameworks for Swift

PromiseKit Google Promises

Reactive programming

RxSwift

Observables and observers Transformations Schedulers Asynchronous networking – an example

Summary

Modularize Your Apps with Swift Package Manager

Creating a library package

Adding features to the library Adding more targets

Adding third-party dependencies

Using SPM with Xcode

Extracting and sharing a framework

Refactoring your code Extracting a framework

Summary

Testing Your Code with Unit and UI Tests

Unit testing using XCTest

Testing an RPN Calculator app

TDD What is an reverse polish notation calculator? A simple RPN Calculator app

The first test More tests Refactoring the tests Adding operations Learnings from our first TDD code

Assertions

Advanced testing with mocks, spy, and others

Testing in Isolation Dummy test double: when we don't need to test the collaborator Fake test double: a simplified collaborator Stub test double: a predefined collaborator Spy test double: verifying collaboration Mock test double: asserting collaboration

UI testing with Xcode

The importance of UI testing Recording a UI test Writing UI tests in code

Tips and tricks

Testing singletons Testing Async code Run only the test with the cursor

Summary

Going Out in the Open (Source)

Documenting Swift

The Markdown language The anatomy of a documentation block

Rich content Additional callouts Structural annotations

Generating HTML docs

Publishing to GitHub Pages

Continuous integration

Travis CI

Configuring simple projects Configuring more complex build scenarios Configuring pure Swift projects

GitLab.com

Building and testing Adding a linter, SwiftLint

Some final words on Travis and GitLab

Using fastlane for automated delivery

Getting started with fastlane Your first lane Fastlane beta Using Travis to upload on tags

Becoming a maintainer, tips and tricks

The README.md file The LICENSE.md file The CODE_OF_CONDUCT.md file Issues, Pull Requests, and more No is temporary, yes is forever

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

← Prev
Back
Next →

← Prev
Back
Next →