Book Image

Mastering Swift 5 - Fifth Edition

By : Jon Hoffman

Book Image

Mastering Swift 5 - Fifth Edition

By: Jon Hoffman

Overview of this book

Over the years, the Mastering Swift book has established itself amongst developers as a popular choice as an in-depth and practical guide to the Swift programming language. The latest edition is fully updated and revised to cover the new version: Swift 5. Inside this book, you'll find the key features of Swift 5 easily explained with complete sets of examples. From the basics of the language to popular features such as concurrency, generics, and memory management, this definitive guide will help you develop your expertise and mastery of the Swift language. Mastering Swift 5, Fifth Edition will give you an in-depth knowledge of some of the most sophisticated elements in Swift development, including protocol extensions, error handling, and closures. It will guide you on how to use and apply them in your own projects. Later, you'll see how to leverage the power of protocol-oriented programming to write flexible and easier-to-manage code. You will also see how to add the copy-on-write feature to your custom value types and how to avoid memory management issues caused by strong reference cycles.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Taking the First Steps with Swift

Taking the First Steps with Swift

Swift language syntax

Learning about Variables, Constants, Strings, and Operators

Learning about Variables, Constants, Strings, and Operators

Constants and variables

The Boolean type

The String type

Optional Types

Introducing optionals

The need for optional types in Swift

Defining an optional

Using optionals

Using Swift Collections

Using Swift Collections

Swift collection types

Control Flow

What have we learned so far?

Conditional statements

Using case and where statements with conditional statements

Control transfer statements

Functions

Using a single parameter function

Using a multi-parameter function

Defining a parameter's default values

Returning multiple values from a function

Adding external parameter names

Using variadic parameters

Inout parameters

Omitting argument labels

Putting it all together

Classes, Structures, and Protocols

Classes, Structures, and Protocols

What are classes and structures?

Value versus reference types

Creating a class or structure

Access controls

Optional chaining

Using Protocols and Protocol Extensions

Using Protocols and Protocol Extensions

Protocols as types

Polymorphism with protocols

Type casting with protocols

Protocol extensions

Do I need to use protocols?

Swift's standard library

Protocol Oriented Design

Protocol Oriented Design

Object-oriented design

Protocol-oriented design

Structures versus classes

The array structure

Generics

Introducing generics

Conditionally adding extensions with generics

Conditional conformance

Availability and Error Handling

Availability and Error Handling

Native error handling

The availability attribute

Custom Subscripting

Custom Subscripting

Introducing subscripts

Subscripts with Swift arrays

Dynamic member lookup

Working with Closures

Working with Closures

An introduction to closures

Concurrency and Parallelism in Swift

Concurrency and Parallelism in Swift

Concurrency and parallelism

Grand Central Dispatch

Using the Operation and OperationQueue types

Custom Types

Value types and reference types

Implementing the equatable protocol

Memory Management

Memory Management

Strong reference cycles

Swift Formatting and Style Guider

Swift Formatting and Style Guider

What is a programming style guide?

Your style guide

Adopting Design Patterns in Swift

Adopting Design Patterns in Swift

What are design patterns?

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

The array structure

At the end of Chapter 6, Using Protocols and Protocol Extensions, we looked at the array structure provided in the Swift standard library. Now that we have a better understanding of protocol-oriented design, let's look at the protocol hierarchy for this structure again. The following diagram shows the protocol hierarchy:

As we can see, the protocol hierarchy for the array structure uses protocol-oriented design. Protocol inheritance is used in several places within the array protocol hierarchy. For example, the Collection protocol inherits from the Sequence protocol, and the MutableCollection protocol inherits from the Collection protocol.

Protocol composition is used because the array protocol inherits directly from eight different protocols. When you add in the protocol inheritance and composition, the array actually conforms to all 14 protocols shown...