Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Mastering Swift 5.3 - Sixth Edition

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

inout parameters

If we want to change the value of a parameter and we want those changes to persist once the function ends, we need to define the parameter as an inout parameter. Any changes made to an inout parameter are passed back to the variable that was used in the function call.

Two things to keep in mind when we use inout parameters are that these parameters cannot have default values and that they cannot be variadic parameters.

Let's look at how to use inout parameters to swap the values of two variables:

func reverse(first: inout String, second: inout String) { 
    let tmp = first
    first = second
    second = tmp
}

This function will accept two parameters and swap the values of the variables that are used in the function call. When we make the function call, we put an ampersand (&) in front of the variable name, indicating that the function can modify its value. The following example shows how to call the reverse function:

var one = &quot...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Mastering Swift 5.3

Search

Your notes and bookmarks