Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Mastering Swift 5.3

By : Jon Hoffman

3.7 (15)

Mastering Swift 5.3

3.7 (15)

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

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Taking the First Steps with Swift

Taking the First Steps with Swift

What is Swift?

Swift features

Playgrounds

Swift language syntax

Hello World

Summary

Free Chapter

Swift Documentation and Installing Swift

Swift Documentation and Installing Swift

Swift.org

Swift documentation

Installing Swift from swift.org

Building Swift and the Swift toolchain from source

Using the Swift package manager

Using the Swift compiler

Summary

Learning about Variables, Constants, Strings, and Operators

Learning about Variables, Constants, Strings, and Operators

Constants and variables

Numeric types

The Boolean type

The String type

Tuples

Enumerations

Operators

Summary

Optional Types

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

Arrays

Dictionaries

Set

Summary

Control Flow

Control Flow

What have we learned so far?

Curly brackets

Parentheses

Control flow

Conditional statements

Loops

Using case and where statements with conditional statements and loops

Control transfer statements

Summary

Functions

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

Summary

Classes, Structures, and Protocols

Classes, Structures, and Protocols

What are classes and structures?

Value versus reference types

Creating a class or structure

Properties

Methods

Access controls

Key-path expressions as functions

Calling a type as a function

Inheritance

Protocols

Extensions

Property wrappers

Optional chaining

Summary

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

Summary

Protocol-Oriented Design

Protocol-Oriented Design

Requirements

Object-oriented design

Protocol-oriented design

Structures versus classes

Summary

Generics

Generics

Introducing generics

Generic functions

Generic types

Generic subscripts

Associated types

Summary

Error Handling and Availability

Error Handling and Availability

Native error handling

Catching errors

Multi-pattern catch clauses

The availability attribute

Summary

Custom Subscripting

Custom Subscripting

Introducing subscripts

Subscripts with Swift arrays

Dynamic member lookup

When not to use a custom subscript

Summary

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

Summary

Advanced and Custom Operators

Advanced and Custom Operators

Bits and bytes

Endianness

Bitwise operators

Overflow operators

Operator methods

Custom operators

Summary

Concurrency and Parallelism in Swift

Concurrency and Parallelism in Swift

Concurrency and parallelism

Grand Central Dispatch (GCD)

Using the Operation and OperationQueue types

Summary

Custom Value Types

Custom Value Types

Value types and reference types

Implementing the Equatable protocol

Summary

Memory Management

Memory Management

How ARC works

Strong reference cycles

Summary

Swift Formatting and Style Guide

Swift Formatting and Style Guide

What is a programming style guide?

API Design Guide

Summary

Adopting Design Patterns in Swift

Adopting Design Patterns in Swift

What are design patterns?

Creational design patterns

Structural design patterns

Behavioral design patterns

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Index

Index

Customer Reviews

3.7 (15)

5 star

33.3%

4 star

33.3%

3 star

13.3%

2 star

13.3%

1 star

6.7%

Catching errors

When an error is thrown from a function, we need to catch it in the code that called it; this is done using the do-catch block. We use the try keyword, within the do-catch block, to identify the places in the code that may throw an error. The do-catch block with a try statement has the following syntax:

do {
    try [Some function that throws]
    [Code if no error was thrown]
} catch [pattern] {
    [Code if function threw error]
}

If an error is thrown, it is propagated out until it is handled by a catch clause. The catch clause consists of the catch keyword, followed by a pattern to match the error against. If the error matches the pattern, the code within the catch block is executed.

Let's look at how to use the do-catch block by calling both the getPlayerByNumber() and addPlayer() methods of the BaseballTeam structure. Let's look at the getPlayerByNumber() method first, since it only throws one error condition:

do {
    let player =...

Search

Your notes and bookmarks