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%

Using case and where statements with conditional statements and loops

As we saw with switch statements, the case and where statements within a switch statement can be very powerful. Using case and where statements within our conditional statements can also make our code much smaller and easier to read. Conditional statements and loops, such as if, for, and while, can also make use of the where and case keywords. Let's take a look at some examples, starting off with using the where statement to filter the results in a for-in loop.

Filtering with the where statement

In this example, we take an array of integers and print out only multiples of 3. However, before we look at how to filter the results with the where statement, let's take a look at how to do this without the where statement:

for number in 1...30 { 
    if number % 3 == 0 {
        print(number)
    }
}

In this example, we use a for-in loop to cycle through the numbers 1 to 30. Within the for-in...

Search

Your notes and bookmarks