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

Summary

When we are developing an application in a team environment, it is important to have a well-defined coding style that is adhered to by everyone on the team. This allows us to have a code base that is easy to read and maintain.

If a style guide remains static for too long, it means that it is probably not keeping up with the latest changes within the language. What is considered "too long" is different for each language. For example, with the C language, too long will be defined in years, since the language is very stable; however, with Swift, the language is relatively new, and changes come pretty often, so "too long" can probably be defined as a couple of months.

It is recommended that we keep our style guides in a version control system so that we can refer to older versions if need be. This allows us to pull older versions of the style guide and refer back to them when we are looking at older code.

It is recommended, not only with Swift but...