Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Mastering Swift 6 - Seventh Edition

By : Jon Hoffman

5 (2)

Mastering Swift 6

5 (2)

By: Jon Hoffman

Overview of this book

This seventh edition of Mastering Swift 6 is your ultimate guide to harnessing the full power of Swift. Whether you're aiming to optimize the performance of your applications or looking to explore the exciting new features in Swift 6.2, this book has you covered. The author distills his 28 years of experience in the Engineering and IT fields to help you dive deep into advanced concepts and techniques, such as concurrency, memory management, and Generics, all essential for creating high-performance applications. The chapters take you on a flexible journey, covering Swift 6.2’s newest features alongside advanced programming topics such as reflection, concurrency, and Generics. Packed with best practices, testing strategies, and modern programming techniques, this book equips you with the skills to develop scalable, high-performance applications with confidence. Whether you're looking to stay competitive or simply want to excel in Swift 6, this book provides the tools and knowledge you need to succeed.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

The Evolution of Swift

The Evolution of Swift

Getting the most out of this book – get to know your free benefits

How Swift has evolved

Migrating existing projects to Swift 6

How swift.org can help you

Summary

Closures and Result Builders

Closures and Result Builders

Introducing closures

Simple closures

Shorthand syntax for closures

Using closures with Swift arrays

Multiple trailing closures

Advanced closures example

Result builders

Summary

Protocols and Protocol Extensions

Protocols and Protocol Extensions

Protocols as types

Polymorphism with protocols

Typecasting with protocols

Using protocols with enumerations

Protocol extensions

Any and any

Adopting protocols using a synthesized implementation

Summary

Generics

Generics

Introducing generics

Generic functions

Type constraints

Generic types

Generic subscripts

Associated types

Implicitly opened existentials

Summary

Value and Reference Types

Value and Reference Types

Value types and reference types

Summary

Enumerations

Enumerations

Raw values

Associated values

Pattern matching

Enumeration iteration

Going beyond basic values

Summary

Reflection

Reflection

Reflection and the Mirror API

Getting started with the Mirror API

CustomReflectable protocol

Serializing objects

Summary

Error Handling and Availability

Error Handling and Availability

Native error handling

Catching errors

The LocalizedError protocol

Defer functions

Multi-pattern catch clauses

Typed throws

The availability attribute

Unavailability

Summary

Regular Expressions

Regular Expressions

How regular expressions are built

Regular expression literals

Regex type

RegexBuilder

Summary

Custom Subscripting

Custom Subscripting

Introducing subscripts

Subscripts with Swift arrays

Creating and using custom subscripts

External names for subscripts

Multidimensional subscripts

Extending types with subscripts

When not to use a custom subscript

Summary

Property Observers and Wrappers

Property Observers and Wrappers

Introducing property observers

Using property observers

Introducing property wrappers

Using property wrappers

Observation of values

Summary

Dynamic Member Lookup and Key Paths

Dynamic Member Lookup and Key Paths

Dynamic member lookup

Key paths

Static properties

Using key paths and dynamic member lookups together

Summary

Grand Central Dispatch

Grand Central Dispatch

Concurrency and parallelism

GCD

Executing code on the main queue function

async versus sync methods with GCD

Dispatch groups

Barriers

Dispatch semaphores

Summary

Structured Concurrency

Structured Concurrency

Data race conditions and Swift 6

Asynchronous functions

Tasks

Task groups

Actors

Global actors

Sendable types

Adapting completion handlers to async/await

Strict concurrency checking

Default actor isolation

Summary

Memory Management

Memory Management

Introducing ARC

How ARC works

Strong reference cycles

Retain cycles and closures

InlineArray

Summary

Advanced and Custom Operators

Advanced and Custom Operators

Bits and bytes

Bitwise operators

BinaryInteger extension

Overflow operators

Operator methods

Custom operators

Summary

Access Controls

Access Controls

Introducing access control

Access control levels

Access levels with enumerations

Access levels for getters and setters

Best practices for access control

Summary

Swift Testing

Swift Testing

Getting started with Swift Testing

Building blocks for Swift Testing

Swift Testing example

Summary

Object-Oriented Programming

Object-Oriented Programming

What is OOP?

Requirements for the example code

Using object-oriented design

Issues with the object-oriented design

Summary

Protocol-Oriented Programming

Protocol-Oriented Programming

What is POP?

Requirements for the sample code

Using POP

Protocol inheritance

Protocol composition

Protocol-oriented design

Swift standard library

Summary

Functional Programming with Swift

Functional Programming with Swift

Core principles of functional programming

Advanced functional programming techniques

Summary

Unlock Your Book’s Exclusive Benefits

Unlock Your Book’s Exclusive Benefits

How to unlock these benefits in three easy steps

Other Books You May Enjoy

Other Books You May Enjoy

Index

Index

Getting Started with the Mirror API

Before we explore the capabilities of the Mirror API, we will need to create a type that can be used for the examples. Let's create the following Person structure:

struct Person {
    var firstName: String
    var lastName: String
    var age: Int
}

In this structure we define three properties, firstName and lastName both of the string type and age which is an integer type. Now let's see how we would use the Mirror API with our this type.

let person = Person(firstName: "Jon", lastName: "Hoffman", age: 55)
let mirror = Mirror(reflecting: person)

This code starts off by creating an instance of the Person type. We then create an instance of the Mirror type using the Person instance. Now we can use the mirror instance to access different attributes in order to inspect the person instance.

Let's see how we can use the displayStyle and subjectType properties using the mirror instance. The following code will display...

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 6

Search

Your notes and bookmarks