Book Image

Mastering Swift 5.3 - Sixth Edition

By : Jon Hoffman

Book Image

Mastering Swift 5.3 - Sixth Edition

By: Jon Hoffman

Overview of this book

Over the years, Mastering Swift has proven itself among developers as a popular choice for an in-depth and practical guide to the Swift programming language. This sixth edition comes with the latest features, an overall revision to align with Swift 5.3, and two new chapters on building swift from source and advanced operators. From the basics of the language to popular features such as concurrency, generics, and memory management, this in-depth guide will help you develop your expertise and mastery of the language. As you progress, you will gain practical insights into some of the most sophisticated elements in Swift development, including protocol extensions, error handling, and closures. The book will also show you how to use and apply them in your own projects. In later chapters, you will understand how to use the power of protocol-oriented programming to write flexible and easier-to-manage code in Swift. Finally, you will learn how to add the copy-on-write feature to your custom value types, along with understanding how to avoid memory management issues caused by strong reference cycles. By the end of this Swift book, you will have mastered the Swift 5.3 language and developed the skills you need to effectively use its features to build robust applications.

Preface

Who this book is for

What this book covers

To get the most out of this book

Taking the First Steps with Swift

Taking the First Steps with Swift

Swift language syntax

Free Chapter

Swift Documentation and Installing Swift

Swift Documentation and Installing Swift

Swift documentation

Installing Swift from swift.org

Building Swift and the Swift toolchain from source

Using the Swift package manager

Using the Swift compiler

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 and loops

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

Key-path expressions as functions

Calling a type as a function

Property wrappers

Optional chaining

Protocols and Protocol Extensions

Protocols and Protocol Extensions

Protocols as types

Polymorphism with protocols

Typecasting with protocols

Protocol extensions

Do I need to use protocols?

Adopting protocols using a synthesized implementation

Swift's standard library

Protocol-Oriented Design

Protocol-Oriented Design

Object-oriented design

Protocol-oriented design

Structures versus classes

Generics

Introducing generics

Generic functions

Generic subscripts

Associated types

Error Handling and Availability

Error Handling and Availability

Native error handling

Catching errors

Multi-pattern catch clauses

The availability attribute

Custom Subscripting

Custom Subscripting

Introducing subscripts

Subscripts with Swift arrays

Dynamic member lookup

When not to use a custom subscript

Working with Closures

Working with Closures

An introduction to closures

Simple closures

Shorthand syntax for closures

Using closures with Swift arrays

Changing functionality

Selecting a closure based on results

Advanced and Custom Operators

Advanced and Custom Operators

Bitwise operators

Overflow operators

Operator methods

Custom operators

Concurrency and Parallelism in Swift

Concurrency and Parallelism in Swift

Concurrency and parallelism

Grand Central Dispatch (GCD)

Using the Operation and OperationQueue types

Custom Value Types

Custom Value Types

Value types and reference types

Implementing the Equatable protocol

Memory Management

Memory Management

Strong reference cycles

Swift Formatting and Style Guide

Swift Formatting and Style Guide

What is a programming style guide?

API Design Guide

Adopting Design Patterns in Swift

Adopting Design Patterns in Swift

What are design patterns?

Creational design patterns

Structural design patterns

Behavioral design patterns

Other Books You May Enjoy

Other Books You May Enjoy

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Using optionals

The key to using optionals is to always verify that they contain a valid value prior to accessing them. The reason for this is if we attempt to use an optional value without verifying that it contains a valid value, we may encounter a runtime error, causing our application to crash. We use the term unwrapping to refer to the process of retrieving a value from an optional. We are going to introduce two methods for retrieving the values of an optional; please keep in mind that using optional binding is preferred.

Forced unwrapping of an optional

To unwrap or retrieve the value of an optional, we place an exclamation mark (!) after the variable name. This is called forced unwrapping. Forced unwrapping, in this manner, is very dangerous and should be used only if we are certain that the variable contains a non-nil value. Otherwise, if it does contain a nil value, we will get a runtime error and the application will crash.

When we use the exclamation point to...