Mastering Swift 5 by Hoffman, Jon -- Read -- Imperial Library of Trantor

Index

Title Page Copyright and Credits

Mastering Swift 5 Fifth Edition

About Packt

Why subscribe? Packt.com

Contributors

About the author About the reviewers Packt is searching for authors like you

Preface

Who this book is for What this book covers To get the most out of this book

Download the example code files Conventions used

Get in touch

Reviews

Taking the First Steps with Swift

What is Swift? Swift features Playgrounds

Getting started with Playgrounds iOS, tvOS, and macOS Playgrounds Showing images in a Playground Creating and displaying graphs in Playgrounds What Playgrounds are not

Swift language syntax

Comments Semicolons Parentheses Curly brackets An assignment operator does not return a value Spaces are optional in conditional and assignment statements

Hello World Summary

Learning about Variables, Constants, Strings, and Operators

Constants and variables

Defining constants and variables Type safety Type inference Explicit types

Numeric types

Integer types Floating-point and Double values

The Boolean type The String type Tuples Enumerations Operators

Assignment operator Comparison operators Arithmetic operators Remainder operator Compound assignment operators Closed range operator Half open range operator Ternary conditional operator Logical NOT operator Logical AND operator Logical OR operator

Summary

Optional Types

Introducing optionals The need for optional types in Swift Defining an optional Using optionals

Forced unwrapping of an optional Optional binding Optional types with tuples Optional chaining The nil coalescing operator

Summary

Using Swift Collections

Swift collection types

Mutability

Arrays

Creating and initializing arrays Accessing the array element Counting the elements of an array Is the array empty? Shuffling an array Appending to an array Inserting a value into an array Replacing elements in an array Removing elements from an array Merging two arrays Retrieving a subarray from an array Making bulk changes to an array Algorithms for arrays

Sort Sorted Filter Map Count forEach

Iterating over an array

Dictionaries

Creating and initializing dictionaries Accessing dictionary values Counting the key or values in a dictionary Is the dictionary empty? Updating the value of a key Adding a key-value pair Removing a key-value pair

Set

Initializing a set Inserting items into a set Determining the number of items in a set Checking whether a set contains an item Iterating over a set Removing items in a set Set operations

Summary

Control Flow

What have we learned so far? Curly brackets Parentheses Control flow Conditional statements

The if statement

Conditional code execution with the if...else statement

The guard statement The for-in loop

Using the for-in loop

The while loop

Using the while loop Using the repeat-while loop

The switch statement

Switch on tuples Match on wildcard

Using case and where statements with conditional statements

Filtering with the where statement Filtering with the for-case statement Using the if-case statement

Control transfer statements

The continue statement The break statement The fallthrough statement

Summary

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

What are classes and structures?

Similarities between classes and structures Differences between classes and structures

Value versus reference types Creating a class or structure Properties

Stored properties Computed properties Property observers

Methods

Custom initializers Internal and external parameter names Failable initializers

Access controls Inheritance

Overriding methods and properties Overriding methods Overriding properties Preventing overrides

Protocols

Protocol syntax Property requirements Method requirements

Extensions Optional chaining Summary

Using Protocols and Protocol Extensions

Protocols as types Polymorphism with protocols Type casting with protocols Protocol extensions Do I need to use protocols? Swift's standard library Summary

Protocol Oriented Design

Requirements Object-oriented design Protocol-oriented design

Protocol inheritance Protocol composition Protocol-oriented design Using the where statement with protocols

Structures versus classes The array structure Summary

Generics

Introducing generics

Generic functions Generic types

Conditionally adding extensions with generics Conditional conformance

Generic subscripts Associated types

Summary

Availability and Error Handling

Native error handling

Representing errors Throwing errors Catching errors

The availability attribute Summary

Custom Subscripting

Introducing subscripts Subscripts with Swift arrays

Creating and using custom subscripts Read-only custom subscripts Calculated subscripts Subscript values External names for subscripts Multidimensional subscripts

Dynamic member lookup

When not to use a custom subscript

Summary

Working with Closures

An introduction to closures

Simple closures Shorthand syntax for closures Using closures with Swift's array algorithms Changing functionality Selecting a closure based on results

Summary

Concurrency and Parallelism in Swift

Concurrency and parallelism Grand Central Dispatch

Calculation type Creating queues Creating and using a concurrent queue Creating and using a serial queue Async versus sync Executing code on the main queue function Using asyncAfter

Using the Operation and OperationQueue types

Using BlockOperation Using the addOperation() method of the operation queue Subclassing the Operation class

Summary

Custom Types

Value types and reference types

Recursive data types for reference types Inheritance for reference types Dynamic dispatch

Copy-on-write Implementing the equatable protocol Summary

Memory Management

How ARC works Strong reference cycles Summary

Swift Formatting and Style Guider

What is a programming style guide? Your style guide

Do not use semicolons at the end of statements Do not use parentheses for conditional statements Naming

Custom types

Functions and methods Constants and variables Indenting Comments Using the self keyword Constants and variables Optional types

Using optional binding Using optional chaining instead of optional binding for multiple unwrapping

Using type inference Using shorthand declaration for collections Using switch rather than multiple if statements Don't leave commented-out code in your application

Summary

Adopting Design Patterns in Swift

What are design patterns?

Creational patterns

The singleton design pattern

Understanding the problem Understanding the solution Implementing the singleton pattern

The builder design pattern

Understanding the problem Understanding the solution Implementing the builder pattern

Structural design patterns

The bridge pattern

Understanding the problem Understanding the solution Implementing the bridge pattern

The facade pattern

Understanding the problem Understanding the solution Implementing the facade pattern

The proxy design pattern

Understanding the problem Understanding the solution Implementing the proxy pattern

Behavioral design patterns

The command design pattern

Understanding the problem Understanding the solution Implementing the command pattern

The strategy pattern

Understanding the problem Understanding the solution Implementing the strategy pattern

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

← Prev
Back
Next →

← Prev
Back
Next →