Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Book Overview & Buying Mastering Swift 5.3
  • Table Of Contents Toc
  • Feedback & Rating feedback
Mastering Swift 5.3

Mastering Swift 5.3

By : Jon Hoffman
3.7 (15)
Buy this Book
close
close
Mastering Swift 5.3

Mastering Swift 5.3

3.7 (15)
By: Jon Hoffman
Buy this Book

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.
Table of Contents (23 chapters)
close
close
close
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
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
2
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
3
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
4
Optional Types
Optional Types
Introducing optionals
The need for optional types in Swift
Defining an optional
Using optionals
5
Using Swift Collections
Using Swift Collections
Swift collection types
Arrays
Dictionaries
Set
Summary
6
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
7
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
8
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
9
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
10
Protocol-Oriented Design
Protocol-Oriented Design
Requirements
Object-oriented design
Protocol-oriented design
Structures versus classes
Summary
11
Generics
Generics
Introducing generics
Generic functions
Generic types
Generic subscripts
Associated types
Summary
12
Error Handling and Availability
Error Handling and Availability
Native error handling
Catching errors
Multi-pattern catch clauses
The availability attribute
Summary
13
Custom Subscripting
chevron up
Custom Subscripting
Introducing subscripts
Subscripts with Swift arrays
Dynamic member lookup
When not to use a custom subscript
Summary
14
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
15
Advanced and Custom Operators
Advanced and Custom Operators
Bits and bytes
Endianness
Bitwise operators
Overflow operators
Operator methods
Custom operators
Summary
16
Concurrency and Parallelism in Swift
Concurrency and Parallelism in Swift
Concurrency and parallelism
Grand Central Dispatch (GCD)
Using the Operation and OperationQueue types
Summary
17
Custom Value Types
Custom Value Types
Value types and reference types
Implementing the Equatable protocol
Summary
18
Memory Management
Memory Management
How ARC works
Strong reference cycles
Summary
19
Swift Formatting and Style Guide
Swift Formatting and Style Guide
What is a programming style guide?
API Design Guide
Summary
20
Adopting Design Patterns in Swift
Adopting Design Patterns in Swift
What are design patterns?
Creational design patterns
Structural design patterns
Behavioral design patterns
Summary
21
Other Books You May Enjoy
Other Books You May Enjoy
22
Index
Index

When not to use a custom subscript

As we have seen in this chapter, creating custom subscripts can really enhance our code. However, we should avoid overusing them or using them in a way that is not consistent with standard subscript usage. The way to avoid overusing subscripts is to examine how subscripts are used in Swift's standard libraries.

Let's look at the following example:

class MyNames {
    private var names:[String] = ["Jon", "Kailey", "Kara"] 
    var number: Int {
        get {
            return names.count
        }
    }
    subscript(add name: String) -> String { 
        names.append(name)
            return name
    }
    subscript(index: Int) -> String { 
        get { 
            return names[index]
        }
        set {
            names[index] = newValue
        }
    }
}

In the preceding example, within the MyNames class, we define an array of names that are used within our application. As an example...

Unlock full access

Continue reading for free

A Packt free trial gives you instant online access to our library of over 7000 practical eBooks and videos, constantly updated with the latest in tech
Start a 7-day FREE trial
End of Section 5
Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete

Confirmation

Modal Close icon
claim successful
Order Page Read Now

Buy this book with your credits?

Modal Close icon
Are you sure you want to buy this book with one of your credits?
Close
YES, BUY